1078 lines
37 KiB
C
1078 lines
37 KiB
C
#include "clouseau_private.h"
|
|
|
|
static int clouseau_init_count = 0;
|
|
|
|
static Eet_Data_Descriptor *clouseau_object_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_union_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_textblock_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_edje_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_image_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_text_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_elm_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_connect_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_app_add_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_data_req_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_bmp_info_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_shot_list_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_tree_data_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_tree_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_app_closed_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_highlight_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_bmp_req_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_variant_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_protocol_edd = NULL;
|
|
static Eet_Data_Descriptor *clouseau_map_point_props_edd = NULL;
|
|
|
|
static void
|
|
_clouseau_tree_item_free(Clouseau_Tree_Item *parent)
|
|
{
|
|
Clouseau_Tree_Item *treeit;
|
|
|
|
EINA_LIST_FREE(parent->children, treeit)
|
|
_clouseau_tree_item_free(treeit);
|
|
|
|
clouseau_object_information_free(parent->info);
|
|
eina_stringshare_del(parent->name);
|
|
free(parent);
|
|
}
|
|
|
|
EAPI void
|
|
clouseau_data_tree_free(Eina_List *tree)
|
|
{
|
|
Clouseau_Tree_Item *treeit;
|
|
|
|
EINA_LIST_FREE(tree, treeit)
|
|
_clouseau_tree_item_free(treeit);
|
|
}
|
|
|
|
static const struct {
|
|
Clouseau_Message_Type t;
|
|
const char *name;
|
|
} eet_mapping[] = {
|
|
{ CLOUSEAU_GUI_CLIENT_CONNECT, "GUI_CONNECT" },
|
|
{ CLOUSEAU_APP_CLIENT_CONNECT, "APP_CONNECT" },
|
|
{ CLOUSEAU_APP_ADD, "APP_ADD" },
|
|
{ CLOUSEAU_DATA_REQ, "DATA_REQ" },
|
|
{ CLOUSEAU_TREE_DATA, "TREE_DATA" },
|
|
{ CLOUSEAU_APP_CLOSED, "APP_CLOSED" },
|
|
{ CLOUSEAU_HIGHLIGHT, "HIGHLIGHT" },
|
|
{ CLOUSEAU_BMP_REQ, "BMP_REQ" },
|
|
{ CLOUSEAU_BMP_DATA, "BMP_DATA" },
|
|
{ CLOUSEAU_UNKNOWN, NULL }
|
|
};
|
|
|
|
EAPI Clouseau_Message_Type
|
|
clouseau_data_packet_mapping_type_get(const char *name)
|
|
{
|
|
int i;
|
|
if (!name)
|
|
return CLOUSEAU_UNKNOWN;
|
|
|
|
for (i = 0; eet_mapping[i].name != NULL; ++i)
|
|
if (strcmp(name, eet_mapping[i].name) == 0)
|
|
return eet_mapping[i].t;
|
|
|
|
return CLOUSEAU_UNKNOWN;
|
|
}
|
|
|
|
static const char *
|
|
_clouseau_packet_mapping_type_str_get(Clouseau_Message_Type t)
|
|
{
|
|
int i;
|
|
for (i = 0; eet_mapping[i].name != NULL; ++i)
|
|
if (t == eet_mapping[i].t)
|
|
return eet_mapping[i].name;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static const char *
|
|
_clouseau_variant_type_get(const void *data, Eina_Bool *unknow EINA_UNUSED)
|
|
{
|
|
const char * const *type = data;
|
|
int i;
|
|
|
|
for (i = 0; eet_mapping[i].name != NULL; ++i)
|
|
if (strcmp(*type, eet_mapping[i].name) == 0)
|
|
return eet_mapping[i].name;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static Eina_Bool
|
|
_clouseau_variant_type_set(const char *type,
|
|
void *data,
|
|
Eina_Bool unknow EINA_UNUSED)
|
|
{
|
|
const char **t = data;
|
|
|
|
*t = type;
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
EAPI void
|
|
clouseau_data_variant_free(Variant_st *v)
|
|
{
|
|
if (v->data)
|
|
free(v->data);
|
|
|
|
free(v);
|
|
}
|
|
|
|
EAPI Variant_st *
|
|
clouseau_data_variant_alloc(Clouseau_Message_Type t, size_t size, void *info)
|
|
{
|
|
Variant_st *v;
|
|
|
|
if (t == CLOUSEAU_UNKNOWN) return NULL;
|
|
|
|
/* This will allocate variant and message struct */
|
|
v = malloc(sizeof(Variant_st));
|
|
v->data = malloc(size);
|
|
_clouseau_variant_type_set(_clouseau_packet_mapping_type_str_get(t),
|
|
&v->type, EINA_FALSE);
|
|
memcpy(v->data, info, size);
|
|
|
|
return v;
|
|
}
|
|
|
|
static void
|
|
_clouseau_connect_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, connect_st);
|
|
clouseau_connect_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_connect_edd, connect_st,
|
|
"pid", pid, EET_T_UINT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_connect_edd, connect_st,
|
|
"name", name, EET_T_STRING);
|
|
}
|
|
|
|
static void
|
|
_clouseau_app_add_desc_make(void)
|
|
{ /* view field not transferred, will be loaded on user request */
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, app_info_st);
|
|
clouseau_app_add_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_app_add_edd, app_info_st,
|
|
"pid", pid, EET_T_UINT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_app_add_edd, app_info_st,
|
|
"name", name, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_app_add_edd, app_info_st,
|
|
"ptr", ptr, EET_T_ULONG_LONG);
|
|
}
|
|
|
|
static void
|
|
_clouseau_req_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, data_req_st);
|
|
clouseau_data_req_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_data_req_edd, data_req_st,
|
|
"gui", gui, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_data_req_edd, data_req_st,
|
|
"app", app, EET_T_ULONG_LONG);
|
|
}
|
|
|
|
static void
|
|
_clouseau_bmp_info_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, bmp_info_st);
|
|
clouseau_bmp_info_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_info_edd, bmp_info_st,
|
|
"gui", gui, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_info_edd, bmp_info_st,
|
|
"app", app, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_info_edd, bmp_info_st,
|
|
"object", object, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_info_edd, bmp_info_st,
|
|
"ctr", ctr, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_info_edd, bmp_info_st,
|
|
"w", w, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_info_edd, bmp_info_st,
|
|
"h", h, EET_T_ULONG_LONG);
|
|
}
|
|
|
|
static void
|
|
_clouseau_shot_list_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, shot_list_st);
|
|
clouseau_shot_list_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(clouseau_shot_list_edd, shot_list_st,
|
|
"view", view, clouseau_bmp_info_edd);
|
|
}
|
|
|
|
static void
|
|
_clouseau_tree_item_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Tree_Item);
|
|
clouseau_tree_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(clouseau_tree_edd, Clouseau_Tree_Item,
|
|
"children", children, clouseau_tree_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_tree_edd, Clouseau_Tree_Item,
|
|
"name", name, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_tree_edd, Clouseau_Tree_Item,
|
|
"ptr", ptr, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_SUB(clouseau_tree_edd, Clouseau_Tree_Item,
|
|
"info", info, clouseau_object_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_tree_edd, Clouseau_Tree_Item,
|
|
"is_obj", is_obj, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_tree_edd, Clouseau_Tree_Item,
|
|
"is_clipper", is_clipper, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_tree_edd, Clouseau_Tree_Item,
|
|
"is_visible", is_visible, EET_T_UCHAR);
|
|
}
|
|
|
|
static void
|
|
_clouseau_tree_data_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, tree_data_st);
|
|
clouseau_tree_data_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_tree_data_edd, tree_data_st,
|
|
"gui", gui, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_tree_data_edd, tree_data_st,
|
|
"app", app, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(clouseau_tree_data_edd, tree_data_st,
|
|
"tree", tree, clouseau_tree_edd);
|
|
}
|
|
|
|
static void
|
|
_clouseau_app_closed_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, app_closed_st);
|
|
clouseau_app_closed_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_app_closed_edd, app_closed_st,
|
|
"ptr", ptr, EET_T_ULONG_LONG);
|
|
}
|
|
|
|
static void
|
|
_clouseau_highlight_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, highlight_st);
|
|
clouseau_highlight_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_highlight_edd, highlight_st,
|
|
"app", app, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_highlight_edd, highlight_st,
|
|
"object", object, EET_T_ULONG_LONG);
|
|
}
|
|
|
|
static void
|
|
_clouseau_bmp_req_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, bmp_req_st);
|
|
clouseau_bmp_req_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_req_edd, bmp_req_st,
|
|
"gui", gui, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_req_edd, bmp_req_st,
|
|
"app", app, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_req_edd, bmp_req_st,
|
|
"object", object, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_bmp_req_edd, bmp_req_st,
|
|
"ctr", ctr, EET_T_UINT);
|
|
}
|
|
|
|
static struct {
|
|
Clouseau_Object_Type u;
|
|
const char *name;
|
|
} eet_props_mapping[] = {
|
|
/* As eet_mapping */
|
|
{ CLOUSEAU_OBJ_TYPE_OTHER, "CLOUSEAU_OBJ_TYPE_OTHER" },
|
|
{ CLOUSEAU_OBJ_TYPE_ELM, "CLOUSEAU_OBJ_TYPE_ELM" },
|
|
{ CLOUSEAU_OBJ_TYPE_TEXT, "CLOUSEAU_OBJ_TYPE_TEXT" },
|
|
{ CLOUSEAU_OBJ_TYPE_IMAGE, "CLOUSEAU_OBJ_TYPE_IMAGE" },
|
|
{ CLOUSEAU_OBJ_TYPE_EDJE, "CLOUSEAU_OBJ_TYPE_EDJE" },
|
|
{ CLOUSEAU_OBJ_TYPE_TEXTBLOCK, "CLOUSEAU_OBJ_TYPE_TEXTBLOCK" },
|
|
{ CLOUSEAU_OBJ_TYPE_UNKNOWN, NULL }
|
|
};
|
|
|
|
static const char *
|
|
_clouseau_props_union_type_get(const void *data, Eina_Bool *unknow)
|
|
{ /* _union_type_get */
|
|
const Clouseau_Object_Type *u = data;
|
|
int i;
|
|
|
|
if (unknow)
|
|
*unknow = EINA_FALSE;
|
|
|
|
for (i = 0; eet_props_mapping[i].name != NULL; ++i)
|
|
if (*u == eet_props_mapping[i].u)
|
|
return eet_props_mapping[i].name;
|
|
|
|
if (unknow)
|
|
*unknow = EINA_TRUE;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static Eina_Bool
|
|
_clouseau_props_union_type_set(const char *type, void *data, Eina_Bool unknow)
|
|
{ /* same as _union_type_set */
|
|
Clouseau_Object_Type *u = data;
|
|
int i;
|
|
|
|
if (unknow)
|
|
return EINA_FALSE;
|
|
|
|
for (i = 0; eet_props_mapping[i].name != NULL; ++i)
|
|
if (strcmp(eet_props_mapping[i].name, type) == 0)
|
|
{
|
|
*u = eet_props_mapping[i].u;
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
static void
|
|
_clouseau_elm_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Elm_Props);
|
|
clouseau_elm_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_elm_edd, Clouseau_Elm_Props,
|
|
"type", type, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_elm_edd, Clouseau_Elm_Props,
|
|
"style", style, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_elm_edd, Clouseau_Elm_Props,
|
|
"scale", scale, EET_T_DOUBLE);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_elm_edd, Clouseau_Elm_Props,
|
|
"has_focus", has_focus, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_elm_edd, Clouseau_Elm_Props,
|
|
"is_disabled", is_disabled, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_elm_edd, Clouseau_Elm_Props,
|
|
"is_mirrored", is_mirrored, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_elm_edd, Clouseau_Elm_Props,
|
|
"is_mirrored_automatic", is_mirrored_automatic, EET_T_UCHAR);
|
|
}
|
|
|
|
static void
|
|
_clouseau_text_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Evas_Text_Props);
|
|
clouseau_text_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_text_edd, Clouseau_Evas_Text_Props,
|
|
"font", font, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_text_edd, Clouseau_Evas_Text_Props,
|
|
"size", size, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_text_edd, Clouseau_Evas_Text_Props,
|
|
"source", source, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_text_edd, Clouseau_Evas_Text_Props,
|
|
"text", text, EET_T_STRING);
|
|
}
|
|
|
|
static void
|
|
_clouseau_image_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Evas_Image_Props);
|
|
clouseau_image_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_image_edd, Clouseau_Evas_Image_Props,
|
|
"file", file, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_image_edd, Clouseau_Evas_Image_Props,
|
|
"key", key, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_image_edd, Clouseau_Evas_Image_Props,
|
|
"source", source, EET_T_UINT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_image_edd, Clouseau_Evas_Image_Props,
|
|
"load_err", load_err, EET_T_STRING);
|
|
}
|
|
|
|
static void
|
|
_clouseau_edje_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Edje_Props);
|
|
clouseau_edje_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_edje_edd, Clouseau_Edje_Props,
|
|
"file", file, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_edje_edd, Clouseau_Edje_Props,
|
|
"group", group, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_edje_edd, Clouseau_Edje_Props,
|
|
"load_err", load_err, EET_T_STRING);
|
|
}
|
|
|
|
static void
|
|
_clouseau_textblock_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Evas_Textblock_Props);
|
|
clouseau_textblock_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_textblock_edd, Clouseau_Evas_Textblock_Props,
|
|
"style", style, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_textblock_edd, Clouseau_Evas_Textblock_Props,
|
|
"text", text, EET_T_STRING);
|
|
}
|
|
|
|
static void
|
|
_clouseau_map_point_props_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc,
|
|
Clouseau_Evas_Map_Point_Props);
|
|
|
|
clouseau_map_point_props_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_map_point_props_edd,
|
|
Clouseau_Evas_Map_Point_Props, "x", x, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_map_point_props_edd,
|
|
Clouseau_Evas_Map_Point_Props, "y", y, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_map_point_props_edd,
|
|
Clouseau_Evas_Map_Point_Props, "z", z, EET_T_INT);
|
|
}
|
|
|
|
static void
|
|
_clouseau_object_desc_make(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Object);
|
|
clouseau_object_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
/* START - evas_props Struct desc */
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.name", evas_props.name, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.bt", evas_props.bt, EET_T_STRING);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.layer", evas_props.layer, EET_T_SHORT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.x", evas_props.x, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.y", evas_props.y, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.w", evas_props.w, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.h", evas_props.h, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.scale", evas_props.scale, EET_T_DOUBLE);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.min_w", evas_props.min_w, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.min_h", evas_props.min_h, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.max_w", evas_props.max_w, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.max_h", evas_props.max_h, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.req_w", evas_props.req_w, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.req_h", evas_props.req_h, EET_T_INT);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.align_x", evas_props.align_x, EET_T_DOUBLE);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.align_y", evas_props.align_y, EET_T_DOUBLE);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.weight_x", evas_props.weight_x, EET_T_DOUBLE);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.weight_y", evas_props.weight_y, EET_T_DOUBLE);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.r", evas_props.r, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.g", evas_props.g, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.b", evas_props.b, EET_T_INT);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.a", evas_props.a, EET_T_INT);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.pass_events", evas_props.pass_events, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.repeat_events", evas_props.repeat_events, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.propagate_events", evas_props.propagate_events, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.has_focus", evas_props.has_focus, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.is_clipper", evas_props.is_clipper, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.is_visible", evas_props.is_visible, EET_T_UCHAR);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.clipper", evas_props.clipper, EET_T_ULONG_LONG);
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.mode", evas_props.mode, EET_T_INT);
|
|
|
|
_clouseau_elm_desc_make();
|
|
_clouseau_text_desc_make();
|
|
_clouseau_image_desc_make();
|
|
_clouseau_edje_desc_make();
|
|
_clouseau_textblock_desc_make();
|
|
|
|
_clouseau_map_point_props_desc_make();
|
|
EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY(clouseau_object_edd, Clouseau_Object,
|
|
"evas_props.points", evas_props.points,
|
|
clouseau_map_point_props_edd);
|
|
|
|
/* for union */
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Extra_Props);
|
|
eddc.func.type_get = _clouseau_props_union_type_get;
|
|
eddc.func.type_set = _clouseau_props_union_type_set;
|
|
clouseau_union_edd = eet_data_descriptor_file_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_union_edd,
|
|
"CLOUSEAU_OBJ_TYPE_ELM", clouseau_elm_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_union_edd,
|
|
"CLOUSEAU_OBJ_TYPE_TEXT",
|
|
clouseau_text_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_union_edd,
|
|
"CLOUSEAU_OBJ_TYPE_IMAGE",
|
|
clouseau_image_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_union_edd,
|
|
"CLOUSEAU_OBJ_TYPE_EDJE",
|
|
clouseau_edje_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_union_edd,
|
|
"CLOUSEAU_OBJ_TYPE_TEXTBLOCK",
|
|
clouseau_textblock_edd);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_UNION(clouseau_object_edd, Clouseau_Object,
|
|
"u", extra_props.u,
|
|
extra_props.type, clouseau_union_edd);
|
|
}
|
|
|
|
static void
|
|
clouseau_data_descriptors_init(void)
|
|
{
|
|
Eet_Data_Descriptor_Class eddc;
|
|
|
|
_clouseau_bmp_req_desc_make();
|
|
_clouseau_bmp_info_desc_make();
|
|
_clouseau_shot_list_desc_make();
|
|
_clouseau_object_desc_make();
|
|
_clouseau_tree_item_desc_make();
|
|
_clouseau_connect_desc_make();
|
|
_clouseau_app_add_desc_make();
|
|
_clouseau_req_desc_make();
|
|
_clouseau_tree_data_desc_make();
|
|
_clouseau_app_closed_desc_make();
|
|
_clouseau_highlight_desc_make();
|
|
|
|
/* for variant */
|
|
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Variant_st);
|
|
clouseau_protocol_edd = eet_data_descriptor_file_new(&eddc);
|
|
|
|
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
|
|
eddc.func.type_get = _clouseau_variant_type_get;
|
|
eddc.func.type_set = _clouseau_variant_type_set;
|
|
clouseau_variant_edd = eet_data_descriptor_stream_new(&eddc);
|
|
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"GUI_CONNECT", clouseau_connect_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"APP_CONNECT", clouseau_connect_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"APP_ADD" , clouseau_app_add_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"DATA_REQ", clouseau_data_req_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"TREE_DATA", clouseau_tree_data_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"APP_CLOSED", clouseau_app_closed_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"HIGHLIGHT", clouseau_highlight_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"BMP_REQ", clouseau_bmp_req_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
|
|
"BMP_DATA", clouseau_bmp_info_edd);
|
|
EET_DATA_DESCRIPTOR_ADD_VARIANT(clouseau_protocol_edd, Variant_st,
|
|
"data", data, type, clouseau_variant_edd);
|
|
}
|
|
|
|
static void
|
|
clouseau_data_descriptors_shutdown(void)
|
|
{
|
|
eet_data_descriptor_free(clouseau_connect_edd);
|
|
eet_data_descriptor_free(clouseau_app_add_edd);
|
|
eet_data_descriptor_free(clouseau_data_req_edd);
|
|
eet_data_descriptor_free(clouseau_tree_edd);
|
|
eet_data_descriptor_free(clouseau_app_closed_edd);
|
|
eet_data_descriptor_free(clouseau_highlight_edd);
|
|
eet_data_descriptor_free(clouseau_object_edd);
|
|
eet_data_descriptor_free(clouseau_variant_edd);
|
|
eet_data_descriptor_free(clouseau_bmp_req_edd);
|
|
eet_data_descriptor_free(clouseau_bmp_info_edd);
|
|
eet_data_descriptor_free(clouseau_shot_list_edd);
|
|
eet_data_descriptor_free(clouseau_protocol_edd);
|
|
eet_data_descriptor_free(clouseau_elm_edd);
|
|
eet_data_descriptor_free(clouseau_text_edd);
|
|
eet_data_descriptor_free(clouseau_image_edd);
|
|
eet_data_descriptor_free(clouseau_edje_edd);
|
|
eet_data_descriptor_free(clouseau_textblock_edd);
|
|
eet_data_descriptor_free(clouseau_union_edd);
|
|
eet_data_descriptor_free(clouseau_map_point_props_edd);
|
|
}
|
|
|
|
static void *
|
|
_host_to_net_blob_get(void *blob, int *blob_size)
|
|
{
|
|
if (!blob)
|
|
return blob;
|
|
|
|
/* Complete blob_size to sizeof(uint32_t) */
|
|
int mod = (*blob_size) % sizeof(uint32_t);
|
|
if (mod)
|
|
*blob_size += (sizeof(uint32_t) - mod);
|
|
|
|
void *n_blob = malloc(*blob_size);
|
|
uint32_t *src = blob;
|
|
uint32_t *dst = n_blob;
|
|
int cnt = (*blob_size) / sizeof(uint32_t);
|
|
while (cnt)
|
|
{
|
|
*dst = htonl(*src);
|
|
src++;
|
|
dst++;
|
|
cnt--;
|
|
}
|
|
|
|
return n_blob;
|
|
}
|
|
|
|
static void *
|
|
_net_to_host_blob_get(void *blob, int blob_size)
|
|
{
|
|
if (!blob)
|
|
return blob;
|
|
|
|
void *h_blob = malloc(blob_size);
|
|
|
|
uint32_t *src = blob;
|
|
uint32_t *dst = h_blob;
|
|
int cnt = blob_size / sizeof(uint32_t);
|
|
while (cnt)
|
|
{
|
|
*dst = ntohl(*src);
|
|
src++;
|
|
dst++;
|
|
cnt--;
|
|
}
|
|
|
|
return h_blob;
|
|
}
|
|
|
|
EAPI void *
|
|
clouseau_data_packet_compose(Clouseau_Message_Type t, void *data,
|
|
int data_size, int *size,
|
|
void *blob, int blob_size)
|
|
{
|
|
/* Returns packet BLOB and size in size param, NULL on failure */
|
|
/* Packet is composed of packet type BYTE + packet data. */
|
|
void *p = NULL;
|
|
void *pb = NULL;
|
|
unsigned char p_type = VARIANT_PACKET;
|
|
Variant_st *v;
|
|
|
|
switch (t)
|
|
{
|
|
case CLOUSEAU_BMP_DATA:
|
|
{ /* Builed Bitmap data as follows:
|
|
First we have encoding size of bmp_info_st
|
|
(Done Network Byte Order)
|
|
The next to come will be the encoded bmp_info_st itself
|
|
folloed by the Bitmap raw data. */
|
|
|
|
/* First, we like to encode bmp_info_st from data */
|
|
int e_size;
|
|
uint32_t enc_size;
|
|
void *net_blob;
|
|
char *b;
|
|
|
|
v = clouseau_data_variant_alloc(t, data_size, data);
|
|
p = eet_data_descriptor_encode(clouseau_protocol_edd, v, &e_size);
|
|
clouseau_data_variant_free(v);
|
|
|
|
/* Save encoded size in network format */
|
|
enc_size = htonl((uint32_t) e_size);
|
|
net_blob = _host_to_net_blob_get(blob, &blob_size);
|
|
|
|
/* Update size to the buffer size we about to return */
|
|
*size = (e_size + blob_size + sizeof(enc_size));
|
|
b = malloc(*size);
|
|
|
|
/* Copy encoded-size first, followd by encoded data */
|
|
memcpy(b, &enc_size, sizeof(enc_size));
|
|
memcpy(b + sizeof(enc_size), p, e_size);
|
|
free(p);
|
|
|
|
if (net_blob) /* Copy BMP info */
|
|
{
|
|
memcpy(b + sizeof(enc_size) + e_size, net_blob, blob_size);
|
|
free(net_blob);
|
|
}
|
|
|
|
p_type = BMP_RAW_DATA;
|
|
p = b;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
/* All others are variant packets with EET encoding */
|
|
/* Variant is composed of message type + ptr to data */
|
|
v = clouseau_data_variant_alloc(t, data_size, data);
|
|
p = eet_data_descriptor_encode(clouseau_protocol_edd, v, size);
|
|
clouseau_data_variant_free(v);
|
|
}
|
|
}
|
|
|
|
pb = malloc((*size) + 1);
|
|
*((unsigned char *) pb) = p_type;
|
|
memcpy(((char *) pb) + 1, p, *size);
|
|
*size = (*size) + 1; /* Add space for packet type */
|
|
free(p);
|
|
|
|
return pb; /* User has to free(pb) */
|
|
}
|
|
|
|
EAPI Variant_st *
|
|
clouseau_data_packet_info_get(void *data, int size)
|
|
{
|
|
/* user has to use variant_free() to free return struct */
|
|
char *ch = data;
|
|
Variant_st *v;
|
|
|
|
if (size <= 0)
|
|
return NULL;
|
|
|
|
switch (*ch)
|
|
{
|
|
case BMP_RAW_DATA:
|
|
{
|
|
void *bmp = NULL;
|
|
bmp_info_st *st;
|
|
char *b;
|
|
uint32_t enc_size;
|
|
int blob_size;
|
|
|
|
b = (char *) (ch + 1);
|
|
enc_size = ntohl(*(uint32_t *) b);
|
|
/* blob_size is total size minus 1st byte and enc_size size */
|
|
blob_size = size - (enc_size + 1 + sizeof(enc_size));
|
|
if (blob_size)
|
|
{
|
|
/* Allocate BMP only if was included in packet */
|
|
bmp = _net_to_host_blob_get(b + sizeof(enc_size) + enc_size,
|
|
blob_size);
|
|
}
|
|
|
|
/* User have to free both: variant_free(rt), free(t->bmp) */
|
|
v = eet_data_descriptor_decode(clouseau_protocol_edd,
|
|
b + sizeof(enc_size), enc_size);
|
|
|
|
st = v->data;
|
|
st->bmp = bmp;
|
|
return v;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return eet_data_descriptor_decode(clouseau_protocol_edd,
|
|
ch + 1, size - 1);
|
|
}
|
|
}
|
|
|
|
/* HIGHLIGHT code. */
|
|
static Eina_Bool
|
|
_clouseau_highlight_fade(void *_rect)
|
|
{
|
|
Evas_Object *rect = _rect;
|
|
int r, g, b, a;
|
|
double na;
|
|
|
|
evas_object_color_get(rect, &r, &g, &b, &a);
|
|
if (a < 20)
|
|
{
|
|
evas_object_del(rect);
|
|
/* The del callback of the object will destroy the animator */
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
na = a - 5;
|
|
r = na / a * r;
|
|
g = na / a * g;
|
|
b = na / a * b;
|
|
evas_object_color_set(rect, r, g, b, na);
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
static Evas_Object *
|
|
_clouseau_verify_e_children(Evas_Object *obj, Evas_Object *ptr)
|
|
{
|
|
/* Verify that obj still exists (can be found on evas canvas) */
|
|
Evas_Object *child;
|
|
Evas_Object *p = NULL;
|
|
Eina_List *children;
|
|
|
|
if (ptr == obj)
|
|
return ptr;
|
|
|
|
children = evas_object_smart_members_get(obj);
|
|
EINA_LIST_FREE(children, child)
|
|
{
|
|
p = _clouseau_verify_e_children(child, ptr);
|
|
if (p) break;
|
|
}
|
|
eina_list_free(children);
|
|
|
|
return p;
|
|
}
|
|
|
|
static Evas_Object *
|
|
_clouseau_verify_e_obj(Evas_Object *obj)
|
|
{
|
|
/* Verify that obj still exists (can be found on evas canvas) */
|
|
Evas_Object *o;
|
|
Eina_List *ees;
|
|
Ecore_Evas *ee;
|
|
Evas_Object *rt = NULL;
|
|
|
|
ees = ecore_evas_ecore_evas_list_get();
|
|
EINA_LIST_FREE(ees, ee)
|
|
{
|
|
Evas *e;
|
|
Eina_List *objs;
|
|
|
|
e = ecore_evas_get(ee);
|
|
objs = evas_objects_in_rectangle_get(e, SHRT_MIN, SHRT_MIN,
|
|
USHRT_MAX, USHRT_MAX,
|
|
EINA_TRUE, EINA_TRUE);
|
|
|
|
EINA_LIST_FREE(objs, o)
|
|
{
|
|
rt = _clouseau_verify_e_children(o, obj);
|
|
if (rt) break;
|
|
}
|
|
eina_list_free(objs);
|
|
|
|
if (rt) break;
|
|
}
|
|
eina_list_free(ees);
|
|
|
|
return rt;
|
|
}
|
|
|
|
static void
|
|
_clouseau_highlight_del(void *data,
|
|
EINA_UNUSED Evas *e,
|
|
EINA_UNUSED Evas_Object *obj,
|
|
EINA_UNUSED void *event_info)
|
|
{ /* Delete timer for this rect */
|
|
ecore_animator_del(data);
|
|
}
|
|
|
|
EAPI void
|
|
clouseau_data_object_highlight(Evas_Object *obj, Clouseau_Evas_Props *props, bmp_info_st *view)
|
|
{
|
|
Ecore_Animator *t;
|
|
Evas_Object *r;
|
|
int x, y, wd, ht;
|
|
Evas *e = NULL;
|
|
|
|
if (props)
|
|
{
|
|
/* When working offline grab info from struct */
|
|
Evas_Coord x_bmp, y_bmp;
|
|
|
|
evas_object_geometry_get(view->o, &x_bmp, &y_bmp, NULL, NULL);
|
|
x = (view->zoom_val * props->x) + x_bmp;
|
|
y = (view->zoom_val * props->y) + y_bmp;
|
|
wd = (view->zoom_val * props->w);
|
|
ht = (view->zoom_val * props->h);
|
|
|
|
e = evas_object_evas_get(view->win);
|
|
}
|
|
else
|
|
{
|
|
/* Check validity of object when working online */
|
|
if (!_clouseau_verify_e_obj(obj))
|
|
{
|
|
printf("<%s> Evas Object not found <%p> (probably deleted)\n",
|
|
__func__, obj);
|
|
return;
|
|
}
|
|
|
|
evas_object_geometry_get(obj, &x, &y, &wd, &ht);
|
|
|
|
/* Take evas from object if working online */
|
|
e = evas_object_evas_get(obj);
|
|
if (!e) return;
|
|
}
|
|
|
|
/* Continue and do the Highlight */
|
|
r = evas_object_rectangle_add(e);
|
|
evas_object_move(r, x - PADDING, y - PADDING);
|
|
evas_object_resize(r, wd + (2 * PADDING), ht + (2 * PADDING));
|
|
evas_object_color_set(r,
|
|
HIGHLIGHT_R, HIGHLIGHT_G, HIGHLIGHT_B, HIGHLIGHT_A);
|
|
evas_object_show(r);
|
|
|
|
/* Add Timer for fade and a callback to delete timer on obj del */
|
|
t = ecore_animator_add(_clouseau_highlight_fade, r);
|
|
evas_object_event_callback_add(r, EVAS_CALLBACK_DEL,
|
|
_clouseau_highlight_del, t);
|
|
/* Print backtrace info, saved for future ref
|
|
tmp = evas_object_data_get(obj, ".clouseau.bt");
|
|
fprintf(stderr, "Creation backtrace :\n%s*******\n", tmp); */
|
|
}
|
|
|
|
EAPI Eina_Bool
|
|
clouseau_data_eet_info_save(const char *filename,
|
|
app_info_st *a, tree_data_st *ftd, Eina_List *ck_list)
|
|
{
|
|
Eina_List *shots = NULL;
|
|
Eina_List *l;
|
|
Eet_File *fp;
|
|
Evas_Object *ck;
|
|
|
|
fp = eet_open(filename, EET_FILE_MODE_WRITE);
|
|
if (!fp) return EINA_FALSE;
|
|
|
|
eet_data_write(fp, clouseau_app_add_edd, CLOUSEAU_APP_ADD_ENTRY,
|
|
a, EINA_TRUE);
|
|
eet_data_write(fp, clouseau_tree_data_edd, CLOUSEAU_TREE_DATA_ENTRY,
|
|
ftd, EINA_TRUE);
|
|
|
|
/* Build list of (bmp_info_st *) according to user selection */
|
|
EINA_LIST_FOREACH(ck_list, l , ck)
|
|
if (elm_check_state_get(ck))
|
|
{
|
|
void *data;
|
|
|
|
data = evas_object_data_get(ck, BMP_FIELD);
|
|
if (data)
|
|
shots = eina_list_append(shots, data);
|
|
}
|
|
|
|
if (shots)
|
|
{
|
|
/* Write list and bitmaps */
|
|
char buf[1024];
|
|
shot_list_st t;
|
|
bmp_info_st *st;
|
|
|
|
t.view = shots;
|
|
eet_data_write(fp, clouseau_shot_list_edd, CLOUSEAU_BMP_LIST_ENTRY,
|
|
&t, EINA_TRUE);
|
|
EINA_LIST_FREE(shots, st)
|
|
{
|
|
sprintf(buf, CLOUSEAU_BMP_DATA_ENTRY"/%llx", st->object);
|
|
eet_data_image_write(fp, buf, st->bmp,
|
|
st->w, st->h, 1, 0, 100, 0);
|
|
}
|
|
}
|
|
|
|
eet_close(fp);
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
EAPI Eina_Bool
|
|
clouseau_data_eet_info_read(const char *filename,
|
|
app_info_st **a, tree_data_st **ftd)
|
|
{
|
|
bmp_info_st *st;
|
|
shot_list_st *t;
|
|
Eet_File *fp;
|
|
|
|
fp = eet_open(filename, EET_FILE_MODE_READ);
|
|
if (!fp) return EINA_FALSE;
|
|
|
|
*a = eet_data_read(fp, clouseau_app_add_edd, CLOUSEAU_APP_ADD_ENTRY);
|
|
*ftd = eet_data_read(fp, clouseau_tree_data_edd, CLOUSEAU_TREE_DATA_ENTRY);
|
|
t = eet_data_read(fp, clouseau_shot_list_edd, CLOUSEAU_BMP_LIST_ENTRY);
|
|
|
|
EINA_LIST_FREE(t->view, st)
|
|
{
|
|
Variant_st *v;
|
|
char buf[1024];
|
|
int alpha;
|
|
int compress;
|
|
int quality;
|
|
int lossy;
|
|
|
|
sprintf(buf, CLOUSEAU_BMP_DATA_ENTRY"/%llx", st->object);
|
|
st->bmp = eet_data_image_read(fp, buf,
|
|
(unsigned int *) &st->w,
|
|
(unsigned int *) &st->h,
|
|
&alpha, &compress, &quality, &lossy);
|
|
|
|
/* Add the bitmaps to the actuall app data struct */
|
|
v = clouseau_data_variant_alloc(CLOUSEAU_BMP_DATA, sizeof(*st), st);
|
|
(*a)->view = eina_list_append((*a)->view, v);
|
|
}
|
|
|
|
free(t);
|
|
eet_close(fp);
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
EAPI int
|
|
clouseau_data_init(void)
|
|
{
|
|
if (clouseau_init_count++ != 0)
|
|
return clouseau_init_count;
|
|
|
|
eina_init();
|
|
eet_init();
|
|
ecore_init();
|
|
|
|
clouseau_data_descriptors_init();
|
|
|
|
return clouseau_init_count;
|
|
}
|
|
|
|
EAPI int
|
|
clouseau_data_shutdown(void)
|
|
{
|
|
if (--clouseau_init_count != 0)
|
|
return clouseau_init_count;
|
|
|
|
clouseau_data_descriptors_shutdown();
|
|
|
|
ecore_shutdown();
|
|
eet_shutdown();
|
|
eina_shutdown();
|
|
|
|
return clouseau_init_count;
|
|
}
|