#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_protocol_edd = NULL; static Eet_Data_Descriptor *clouseau_map_point_props_edd = NULL; static Eet_Data_Descriptor *eo_string_edd = NULL; static Eet_Data_Descriptor *eo_int_edd = NULL; static Eet_Data_Descriptor *eo_bool_edd = NULL; static Eet_Data_Descriptor *eo_ptr_edd = NULL; static Eet_Data_Descriptor *eo_double_edd = NULL; static Eet_Data_Descriptor *eo_list_edd = NULL; static Eet_Data_Descriptor *eo_dbg_info_edd = NULL; static void _clouseau_eo_info_free(Clouseau_Eo_Dbg_Info *parent) { Clouseau_Eo_Dbg_Info *eo; if (parent->type == EINA_VALUE_TYPE_LIST) EINA_LIST_FREE(parent->un_dbg_info.dbg.list, eo) _clouseau_eo_info_free(eo); else if (parent->type == EINA_VALUE_TYPE_STRING) eina_stringshare_del(parent->un_dbg_info.text.s); eina_stringshare_del(parent->name); free(parent); } static void _clouseau_tree_item_free(Clouseau_Tree_Item *parent) { Clouseau_Tree_Item *treeit; Clouseau_Eo_Dbg_Info *eo; EINA_LIST_FREE(parent->eo_info, eo) _clouseau_eo_info_free(eo); 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 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_LIST(clouseau_tree_edd, Clouseau_Tree_Item, "eo_info", eo_info, eo_dbg_info_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); } /* START EO descs */ struct _Clouseau_Eo_Dbg_Info_Mapping { const Eina_Value_Type *u; const char *name; }; typedef struct _Clouseau_Eo_Dbg_Info_Mapping Clouseau_Eo_Dbg_Info_Mapping; /* It's init later. */ static Clouseau_Eo_Dbg_Info_Mapping eet_dbg_info_mapping[] = { { NULL, EO_DBG_INFO_TYPE_STRING_STR }, { NULL, EO_DBG_INFO_TYPE_INT_STR }, { NULL, EO_DBG_INFO_TYPE_BOOL_STR }, { NULL, EO_DBG_INFO_TYPE_PTR_STR }, { NULL, EO_DBG_INFO_TYPE_DOUBLE_STR }, { NULL, EO_DBG_INFO_TYPE_LIST_STR }, { NULL, NULL } }; static const char * _dbg_info_union_type_get(const void *data, Eina_Bool *unknow) { /* _union_type_get */ const Eina_Value_Type *const *u = data; int i; if (unknow) *unknow = EINA_FALSE; for (i = 0; eet_dbg_info_mapping[i].name != NULL; ++i) if (*u == eet_dbg_info_mapping[i].u) return eet_dbg_info_mapping[i].name; if (unknow) *unknow = EINA_TRUE; return NULL; } static Eina_Bool _dbg_info_union_type_set(const char *type, void *data, Eina_Bool unknow) { /* same as _union_type_set */ Eina_Value_Type **u = data; int i; if (unknow) return EINA_FALSE; for (i = 0; eet_dbg_info_mapping[i].name != NULL; ++i) if (strcmp(eet_dbg_info_mapping[i].name, type) == 0) { *u = (void *) eet_dbg_info_mapping[i].u; return EINA_TRUE; } return EINA_FALSE; } static Eet_Data_Descriptor * clouseau_string_desc_make(void) { Eet_Data_Descriptor *d; Eet_Data_Descriptor_Class eddc; EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_st_string); d = eet_data_descriptor_stream_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC (d, Clouseau_st_string, "s", s, EET_T_STRING); return d; } static Eet_Data_Descriptor * clouseau_int_desc_make(void) { Eet_Data_Descriptor *d; Eet_Data_Descriptor_Class eddc; EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_st_int); d = eet_data_descriptor_stream_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC (d, Clouseau_st_int, "i", i, EET_T_INT); return d; } static Eet_Data_Descriptor * clouseau_bool_desc_make(void) { Eet_Data_Descriptor *d; Eet_Data_Descriptor_Class eddc; EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_st_bool); d = eet_data_descriptor_stream_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC (d, Clouseau_st_bool, "b", b, EET_T_UCHAR); return d; } static Eet_Data_Descriptor * clouseau_ptr_desc_make(void) { Eet_Data_Descriptor *d; Eet_Data_Descriptor_Class eddc; EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_st_ptr); d = eet_data_descriptor_stream_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC (d, Clouseau_st_ptr, "p", p, EET_T_ULONG_LONG); return d; } static Eet_Data_Descriptor * clouseau_double_desc_make(void) { Eet_Data_Descriptor *d; Eet_Data_Descriptor_Class eddc; EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_st_double); d = eet_data_descriptor_stream_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC (d, Clouseau_st_double, "d", d, EET_T_DOUBLE); return d; } static Eet_Data_Descriptor * clouseau_list_desc_make(void) { Eet_Data_Descriptor *d; Eet_Data_Descriptor_Class eddc; EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_st_dbg_list); d = eet_data_descriptor_stream_new(&eddc); EET_DATA_DESCRIPTOR_ADD_LIST (d, Clouseau_st_dbg_list, "list", list, eo_dbg_info_edd); /* Carefull, has to be initiated */ return d; } static void _clouseau_eo_descs_make(void) { Eet_Data_Descriptor_Class eddc; /* Init the eet_dbg_info_mapping */ { int i = 0; eet_dbg_info_mapping[i++].u = EINA_VALUE_TYPE_STRING; eet_dbg_info_mapping[i++].u = EINA_VALUE_TYPE_INT; eet_dbg_info_mapping[i++].u = EINA_VALUE_TYPE_CHAR; eet_dbg_info_mapping[i++].u = EINA_VALUE_TYPE_UINT64; eet_dbg_info_mapping[i++].u = EINA_VALUE_TYPE_DOUBLE; eet_dbg_info_mapping[i++].u = EINA_VALUE_TYPE_LIST; } eo_string_edd = clouseau_string_desc_make(); eo_int_edd = clouseau_int_desc_make(); eo_bool_edd = clouseau_bool_desc_make(); eo_ptr_edd = clouseau_ptr_desc_make(); eo_double_edd = clouseau_double_desc_make(); EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Clouseau_Eo_Dbg_Info); eo_dbg_info_edd = eet_data_descriptor_file_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC (eo_dbg_info_edd, Clouseau_Eo_Dbg_Info, "name", name, EET_T_STRING); EET_DATA_DESCRIPTOR_ADD_BASIC (eo_dbg_info_edd, Clouseau_Eo_Dbg_Info, "type", type, EET_T_LONG_LONG); /* Here because clouseau_list_desc_make() uses eo_dbg_info_edd */ eo_list_edd = clouseau_list_desc_make(); /* for union */ eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION; eddc.func.type_get = _dbg_info_union_type_get; eddc.func.type_set = _dbg_info_union_type_set; clouseau_union_edd = eet_data_descriptor_file_new(&eddc); EET_DATA_DESCRIPTOR_ADD_MAPPING( clouseau_union_edd, EO_DBG_INFO_TYPE_STRING_STR ,eo_string_edd); EET_DATA_DESCRIPTOR_ADD_MAPPING( clouseau_union_edd, EO_DBG_INFO_TYPE_INT_STR ,eo_int_edd); EET_DATA_DESCRIPTOR_ADD_MAPPING( clouseau_union_edd, EO_DBG_INFO_TYPE_BOOL_STR ,eo_bool_edd); EET_DATA_DESCRIPTOR_ADD_MAPPING( clouseau_union_edd, EO_DBG_INFO_TYPE_PTR_STR ,eo_ptr_edd); EET_DATA_DESCRIPTOR_ADD_MAPPING( clouseau_union_edd, EO_DBG_INFO_TYPE_DOUBLE_STR ,eo_double_edd); EET_DATA_DESCRIPTOR_ADD_MAPPING( clouseau_union_edd, EO_DBG_INFO_TYPE_LIST_STR ,eo_list_edd); EET_DATA_DESCRIPTOR_ADD_UNION(eo_dbg_info_edd, Clouseau_Eo_Dbg_Info, "un_dbg_info", un_dbg_info, type, clouseau_union_edd); } /* END EO descs */ static void clouseau_data_descriptors_init(void) { _clouseau_eo_descs_make(); _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(); } static void clouseau_data_descriptors_shutdown(void) { eet_data_descriptor_free(eo_string_edd); eet_data_descriptor_free(eo_int_edd); eet_data_descriptor_free(eo_bool_edd); eet_data_descriptor_free(eo_ptr_edd); eet_data_descriptor_free(eo_double_edd); eet_data_descriptor_free(eo_list_edd); eet_data_descriptor_free(eo_dbg_info_edd); 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_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(const char *p_type, void *data, unsigned int *size, void *blob, int blob_size) { /* Returns packet BLOB and size in size param, NULL on failure */ /* User has to free returned buffer */ /* Packet is composed of Message Type + packet data. */ void *net_blob = NULL; if (!strcmp(p_type, CLOUSEAU_BMP_DATA_STR)) { /* Builed Bitmap data as follows: First uint32_t is encoding size of bmp_info_st The next to come will be the encoded bmp_info_st itself Then we have blob_size param (specifiying bmp-blob-size) folloed by the Bitmap raw data. */ int t_size; /* total size */ int e_size; uint32_t e_size32; uint32_t tmp; void *p; char *b; char *ptr; /* First, we like to encode bmp_info_st from data */ p = eet_data_descriptor_encode(clouseau_bmp_info_edd, data, &e_size); e_size32 = (uint32_t) e_size; /* Allocate buffer to hold whole packet data */ t_size = sizeof(e_size32) + /* encoding size of bmp_info_st */ + e_size /* Encoded bmp_info_st */ + sizeof(e_size32) /* bmp-blob-size */ + blob_size; /* The BMP blob data */ ptr = b = malloc(t_size); /* START - Build BMP_RAW_DATA packet data */ /* Size of encoded bmp_info_st comes next in uint32 format */ memcpy(ptr, &e_size32, sizeof(e_size32)); ptr += sizeof(e_size32); /* Encoded bmp_info_st comes next */ memcpy(ptr, p, e_size); ptr += e_size; /* Size of BMP blob comes next */ tmp = (uint32_t) blob_size; memcpy(ptr, &tmp, sizeof(uint32_t)); ptr += sizeof(uint32_t); if (blob && blob_size) { /* BMP blob info comes right after BMP blob_size */ memcpy(ptr, blob, blob_size); } /* Save encoded size in network format */ net_blob = _host_to_net_blob_get(b, &t_size); *size = t_size; /* Update packet size */ /* All info now in net_blob, free allocated mem */ free(b); free(p); /* END - Build BMP_RAW_DATA packet data */ } return net_blob; } EAPI void * clouseau_data_packet_info_get(const char *p_type, void *data, size_t size) { bmp_info_st *st = NULL; void *host_blob = NULL; char *ptr = NULL; if (size <= 0) return NULL; host_blob = _net_to_host_blob_get(data, size); ptr = host_blob; if (!strcmp(p_type, CLOUSEAU_BMP_DATA_STR)) { uint32_t *e_size32 = (uint32_t *) ptr; int e_size = (int) (*e_size32); /* First Encoded bmp_info_st size */ ptr += sizeof(uint32_t); /* Get the encoded bmp_info_st */ st = eet_data_descriptor_decode(clouseau_bmp_info_edd ,ptr, e_size); ptr += e_size; st->bmp = NULL; /* Next Get bmp-blob-size */ e_size32 = (uint32_t *) ptr; e_size = (int) (*e_size32); /* Get bmp-blob size */ ptr += sizeof(uint32_t); /* Now we need to get the bmp data */ if (e_size) { /* BMP data available, allocate and copy */ st->bmp = malloc(e_size); /* Freed by user */ memcpy(st->bmp, ptr, e_size); } } /* User has to free st, st->bmp */ free(host_blob); return st; } /* 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); if (t) { EINA_LIST_FREE(t->view, st) { 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 */ (*a)->view = eina_list_append((*a)->view, st); } 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_register_descs(Ecore_Con_Eet *eet_svr) { /* Register descriptors for ecore_con_eet */ if (clouseau_init_count) { /* MUST be called after clouseau_data_init */ ecore_con_eet_register(eet_svr, CLOUSEAU_GUI_CLIENT_CONNECT_STR, clouseau_connect_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_APP_CLIENT_CONNECT_STR, clouseau_connect_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_APP_ADD_STR, clouseau_app_add_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_DATA_REQ_STR, clouseau_data_req_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_TREE_DATA_STR, clouseau_tree_data_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_APP_CLOSED_STR, clouseau_app_closed_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_HIGHLIGHT_STR, clouseau_highlight_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_BMP_REQ_STR, clouseau_bmp_req_edd); ecore_con_eet_register(eet_svr, CLOUSEAU_BMP_DATA_STR, clouseau_bmp_info_edd); } 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; }