clouseau/src/lib/extensions/objects_introspection/main.c

#include <Eina.h>
#include <Eolian.h>

#include <Eolian_Debug.h>
#include <Eo_Debug.h>
#include <Evas_Debug.h>

#include "../../Clouseau.h"
#include "gui.h"

#define _EET_ENTRY "config"

static int _module_init_op = EINA_DEBUG_OPCODE_INVALID;
static int _eoids_get_op = EINA_DEBUG_OPCODE_INVALID;
static int _klids_get_op = EINA_DEBUG_OPCODE_INVALID;
static int _obj_info_op = EINA_DEBUG_OPCODE_INVALID;
static int _obj_highlight_op = EINA_DEBUG_OPCODE_INVALID;
static int _win_screenshot_op = EINA_DEBUG_OPCODE_INVALID;
static int _snapshot_do_op = EINA_DEBUG_OPCODE_INVALID;
static int _snapshot_done_op = EINA_DEBUG_OPCODE_INVALID;

typedef struct
{
   uint64_t id;
   Eina_Stringshare *name;
} Class_Info;

typedef struct
{
   uint64_t obj;
   uint64_t parent;
   uint64_t kl_id;
   int thread_id;
   Eina_List *children;
   Eina_List *screenshots;
   Eo *glitem;
   Eo *screenshots_menu;
   Eolian_Debug_Object_Information *eolian_info;
} Obj_Info;

typedef struct
{
   Eina_Stringshare *out_file;

   Eina_List *screenshots;

   char *buffer;
   unsigned int max_len;
   unsigned int cur_len;

   int klids_op;
   int eoids_op;
   int obj_info_op;
} Snapshot;

typedef struct
{
   int wdgs_show_type;
   Eina_Bool highlight;
} Config;

typedef struct
{
   Gui_Win_Widgets *wdgs;
   Snapshot *snapshot;
   Obj_Info *selected_obj;
   Eina_Hash *classes_hash_by_id;
   Eina_Hash *classes_hash_by_name;
   Eina_Hash *objs_hash;
   Eina_List *objs_list_tree;
   Eina_List *screenshots;
   Eina_Debug_Dispatch_Cb old_disp_cb;
   Eina_Bool eo_init_done;
   Eina_Bool eolian_init_done;
   Eina_Bool evas_init_done;
   Eina_Bool clouseau_init_done;
} Instance;

static Eet_Data_Descriptor *_snapshot_edd = NULL;
static Eet_Data_Descriptor *_config_edd = NULL;
static Config *_config = NULL;

static Elm_Genlist_Item_Class *_objs_itc = NULL;
static Elm_Genlist_Item_Class *_obj_kl_info_itc = NULL;
static Elm_Genlist_Item_Class *_obj_func_info_itc = NULL;



static Evas_Object * _obj_info_tootip(void *, Evas_Object *, Evas_Object *, void *);

static Eina_Debug_Error _module_initted_cb(Eina_Debug_Session *, int, void *, int);
static Eina_Debug_Error _eoids_get(Eina_Debug_Session *, int, void *, int);
static Eina_Debug_Error _klids_get(Eina_Debug_Session *, int, void *, int);
static Eina_Debug_Error _obj_info_get(Eina_Debug_Session *, int, void *, int);
static Eina_Debug_Error _snapshot_done_cb(Eina_Debug_Session *, int, void *, int);
static Eina_Debug_Error _win_screenshot_get(Eina_Debug_Session *, int, void *, int);

static const Eina_Debug_Opcode _ops[] =
{
     {"module/init",            &_module_init_op, &_module_initted_cb},
     {"Eo/objects_ids_get",     &_eoids_get_op, &_eoids_get},
     {"Eo/classes_ids_get",     &_klids_get_op, &_klids_get},
     {"Evas/object/highlight",  &_obj_highlight_op, NULL},
     {"Evas/window/screenshot", &_win_screenshot_op, &_win_screenshot_get},
     {"Eolian/object/info_get", &_obj_info_op, &_obj_info_get},
     {"Clouseau/snapshot_do",   &_snapshot_do_op, NULL},
     {"Clouseau/snapshot_done", &_snapshot_done_op, &_snapshot_done_cb},
     {NULL, NULL, NULL}
};

static Clouseau_Extension *
_ext_get(Eo *obj)
{
   if (!obj) return NULL;
   Clouseau_Extension *ext = efl_key_data_get(obj, "__extension");
   if (!ext) ext = _ext_get(efl_parent_get(obj));
   return ext;
}

static void
_config_eet_load()
{
   if (_config_edd) return;
   Eet_Data_Descriptor_Class eddc;

   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Config);
   _config_edd = eet_data_descriptor_stream_new(&eddc);

#define CFG_ADD_BASIC(member, eet_type)\
   EET_DATA_DESCRIPTOR_ADD_BASIC\
   (_config_edd, Config, # member, member, eet_type)

   CFG_ADD_BASIC(wdgs_show_type, EET_T_INT);
   CFG_ADD_BASIC(highlight, EET_T_INT);

#undef CFG_ADD_BASIC
}

static void
_config_save(Clouseau_Extension *ext)
{
   char path[1024];
   sprintf(path, "%s/objects_introspection_config", ext->path_to_config);
   _config_eet_load();
   Eet_File *file = eet_open(path, EET_FILE_MODE_WRITE);
   eet_data_write(file, _config_edd, _EET_ENTRY, _config, EINA_TRUE);
   eet_close(file);
}

static void
_config_load(Clouseau_Extension *ext)
{
   char path[1024];
   sprintf(path, "%s/objects_introspection_config", ext->path_to_config);
   _config_eet_load();
   Eet_File *file = eet_open(path, EET_FILE_MODE_READ);
   if (!file)
     {
        _config = calloc(1, sizeof(Config));
        _config->wdgs_show_type = 0;
        _config->highlight = EINA_TRUE;
        _config_save(ext);
     }
   else
     {
        _config = eet_data_read(file, _config_edd, _EET_ENTRY);
        eet_close(file);
     }
}

static void
_objs_tree_free(Eina_List *parents)
{
   Obj_Info *info;
   EINA_LIST_FREE(parents, info)
     {
        eolian_debug_object_information_free(info->eolian_info);
        _objs_tree_free(info->children);
        free(info);
     }
}

static void
_app_changed(Clouseau_Extension *ext)
{
   static int app_id = -1;
   Instance *inst = ext->data;
   if (inst->objs_list_tree)
     {
        _objs_tree_free(inst->objs_list_tree);
        inst->objs_list_tree = NULL;
     }
   inst->selected_obj = NULL;
   eina_hash_free_buckets(inst->classes_hash_by_id);
   eina_hash_free_buckets(inst->classes_hash_by_name);

   elm_genlist_clear(inst->wdgs->objects_list);
   elm_genlist_clear(inst->wdgs->object_infos_list);
   eina_hash_free_buckets(inst->objs_hash);

   if (app_id != ext->app_id)
     {
        inst->eo_init_done = EINA_FALSE;
        inst->eolian_init_done = EINA_FALSE;
        inst->evas_init_done = EINA_FALSE;
        inst->clouseau_init_done = EINA_FALSE;
        if (ext->app_id)
           eina_debug_session_send(ext->session, ext->app_id, _module_init_op, "eo", 3);
     }
   else
     {
        if (ext->app_id)
           eina_debug_session_send(ext->session, ext->app_id, _klids_get_op, NULL, 0);
     }
   app_id = ext->app_id;
   if (app_id)
     {
        elm_object_item_disabled_set(inst->wdgs->reload_button, EINA_FALSE);
        elm_object_item_disabled_set(inst->wdgs->save_load_bt, EINA_FALSE);
     }
}

static void
_snapshot_buffer_append(Clouseau_Extension *ext, void *buffer)
{
   Instance *inst = ext->data;
   Snapshot *s = inst->snapshot;
   Eina_Debug_Packet_Header *hdr = (Eina_Debug_Packet_Header *)buffer;
   unsigned int size = hdr->size;
   if (s->max_len < s->cur_len + size)
     {
        /* Realloc with addition of 1MB+size */
        s->max_len += size + 1000000;
        s->buffer = realloc(s->buffer, s->max_len);
     }
   memcpy(s->buffer + s->cur_len, buffer, size);
   s->cur_len += size;
}

static Eina_Bool
_snapshot_is_candidate(void *buffer)
{
   Eina_Debug_Packet_Header *hdr = (Eina_Debug_Packet_Header *)buffer;
   if (hdr->opcode == _eoids_get_op ||
         hdr->opcode == _klids_get_op ||
         hdr->opcode == _obj_info_op ||
         hdr->opcode == _win_screenshot_op) return EINA_TRUE;
   else return EINA_FALSE;
}

Eina_Debug_Error
_disp_cb(Eina_Debug_Session *session, void *buffer)
{
   Clouseau_Extension *ext = eina_debug_session_data_get(session);
   if (!ext) return EINA_DEBUG_OK;
   Instance *inst = ext->data;
   if (inst->snapshot && _snapshot_is_candidate(buffer))
     {
        _snapshot_buffer_append(ext, buffer);
     }
   else
     {
        return inst->old_disp_cb(session, buffer);
     }
   return EINA_DEBUG_OK;
}

static void
_post_register_handle(void *data, Eina_Bool flag)
{
   Clouseau_Extension *ext = data;
   if(!flag) return;
   if (ext->app_id)
      eina_debug_session_send(ext->session, ext->app_id, _module_init_op, "eo", 3);
}

static void
_session_changed(Clouseau_Extension *ext)
{
   int i = 0;
   Instance *inst = ext->data;
   _app_changed(ext);
   while (_ops[i].opcode_name)
     {
        if (_ops[i].opcode_id) *(_ops[i].opcode_id) = EINA_DEBUG_OPCODE_INVALID;
        i++;
     }
   if (ext->session)
     {
        eina_debug_session_data_set(ext->session, ext);
        inst->old_disp_cb = eina_debug_session_dispatch_get(ext->session);
        eina_debug_session_dispatch_override(ext->session, _disp_cb);
        eina_debug_opcodes_register(ext->session, _ops, _post_register_handle, ext);

        elm_object_item_text_set(inst->wdgs->save_load_bt, "Save");
        elm_toolbar_item_icon_set(inst->wdgs->save_load_bt, "document-import");
        elm_object_item_disabled_set(inst->wdgs->save_load_bt, EINA_TRUE);
     }
   else
     {
        elm_object_item_text_set(inst->wdgs->save_load_bt, "Load");
        elm_toolbar_item_icon_set(inst->wdgs->save_load_bt, "document-export");
        elm_object_item_disabled_set(inst->wdgs->save_load_bt, EINA_FALSE);
     }
   elm_object_item_disabled_set(inst->wdgs->reload_button, EINA_TRUE);
}

static void
_snapshot_eet_load()
{
   if (_snapshot_edd) return;
   Eet_Data_Descriptor_Class eddc;
   Evas_Debug_Screenshot s;

   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Evas_Debug_Screenshot);
   Eet_Data_Descriptor *evas_shot_edd = eet_data_descriptor_stream_new(&eddc);

#define SHOT_ADD_BASIC(member, eet_type)\
   EET_DATA_DESCRIPTOR_ADD_BASIC\
   (evas_shot_edd, Evas_Debug_Screenshot, # member, member, eet_type)

   SHOT_ADD_BASIC(obj, EET_T_ULONG_LONG);
   SHOT_ADD_BASIC(w, EET_T_INT);
   SHOT_ADD_BASIC(h, EET_T_INT);
   eet_data_descriptor_element_add(evas_shot_edd,
                                   "img", EET_T_CHAR, EET_G_VAR_ARRAY,
                                   (char *)(&(s.img)) - (char *)(&s),
                                   (char *)(&(s.img_size)) - (char *)(&s),
                                   NULL, NULL);
   SHOT_ADD_BASIC(tm_sec, EET_T_INT);
   SHOT_ADD_BASIC(tm_min, EET_T_INT);
   SHOT_ADD_BASIC(tm_hour, EET_T_INT);

#undef SHOT_ADD_BASIC

   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Snapshot);
   _snapshot_edd = eet_data_descriptor_stream_new(&eddc);

#define SNP_ADD_BASIC(member, eet_type)\
   EET_DATA_DESCRIPTOR_ADD_BASIC\
   (_snapshot_edd, Snapshot, # member, member, eet_type)

   SNP_ADD_BASIC(cur_len, EET_T_INT);
   SNP_ADD_BASIC(eoids_op, EET_T_INT);
   SNP_ADD_BASIC(klids_op, EET_T_INT);
   SNP_ADD_BASIC(obj_info_op, EET_T_INT);
   EET_DATA_DESCRIPTOR_ADD_LIST(_snapshot_edd, Snapshot,
         "screenshots", screenshots, evas_shot_edd);

#undef SNP_ADD_BASIC
}

static Eina_Bool
_snapshot_save(Clouseau_Extension *ext)
{
   Instance *inst = ext->data;
   Snapshot *s = inst->snapshot;
   FILE *fp = fopen(s->out_file, "w");
   void *out_buf = NULL;
   int out_size = 0;
   Eina_Bool ret = EINA_FALSE;

   if (!fp)
     {
        printf("Can not open file: \"%s\".\n", s->out_file);
        return EINA_FALSE;
     }
   if (!ext->app_id) goto end;
   _snapshot_eet_load();
   s->eoids_op = _eoids_get_op;
   s->klids_op = _klids_get_op;
   s->obj_info_op = _obj_info_op;
   s->screenshots = inst->screenshots;
   out_buf = eet_data_descriptor_encode(_snapshot_edd, s, &out_size);
   fwrite(&out_size, sizeof(int), 1, fp);
   fwrite(out_buf, 1, out_size, fp);
   printf("Snapshot buffer size %d max %d\n", s->cur_len, s->max_len);
   fwrite(s->buffer, 1, s->cur_len, fp);
   ret = EINA_TRUE;
end:
   fclose(fp);
   return ret;
}

static Snapshot *
_snapshot_buffer_parse(char *buffer, int size)
{
   Snapshot *s = NULL;
   int eet_size = 0;

   if (size < eet_size) return NULL;

   memcpy(&eet_size, buffer, sizeof(int));
   buffer += sizeof(int);

   _snapshot_eet_load();

   s = eet_data_descriptor_decode(_snapshot_edd, buffer, eet_size);
   buffer += eet_size;

   if (s->cur_len) s->buffer = buffer;

   return s;
}

static void
_snapshot_load(Clouseau_Extension *ext, char *buffer, int size)
{
   Evas_Debug_Screenshot *shot;
   unsigned int idx = 0;

   if (!ext) return;

   Instance *inst = ext->data;
   Snapshot *s = _snapshot_buffer_parse(buffer, size);
   if (!s) return;

   _session_changed(ext);

   _eoids_get_op = s->eoids_op;
   _klids_get_op = s->klids_op;
   _obj_info_op = s->obj_info_op;

   /* Prevent free of the buffer */
   while (idx < s->cur_len)
     {
        Eina_Debug_Packet_Header *hdr = (Eina_Debug_Packet_Header *)(s->buffer + idx);
        void *payload = (s->buffer + idx) + sizeof(*hdr);
        size = hdr->size - sizeof(*hdr);
        if (hdr->opcode == _eoids_get_op) _eoids_get((Eina_Debug_Session *)ext, -1, payload, size);
        else if (hdr->opcode == _klids_get_op) _klids_get((Eina_Debug_Session *)ext, -1, payload, size);
        else if (hdr->opcode == _obj_info_op) _obj_info_get((Eina_Debug_Session *)ext, -1, payload, size);
        idx += hdr->size;
     }
   EINA_LIST_FREE(s->screenshots, shot)
     {
        Obj_Info *info = eina_hash_find(inst->objs_hash, &(shot->obj));
        if (!info) continue;
        info->screenshots = eina_list_append(info->screenshots, shot);
        if (info->glitem) elm_genlist_item_update(info->glitem);
     }
   free(s);
   free(buffer);
}

static int
_file_get(const char *filename, char **buffer_out)
{
   char *file_data = NULL;
   int file_size;
   FILE *fp = fopen(filename, "r");
   if (!fp)
     {
        printf("Can not open file: \"%s\".\n", filename);
        return -1;
     }

   fseek(fp, 0, SEEK_END);
   file_size = ftell(fp);
   if (file_size <= 0)
     {
        fclose(fp);
        if (file_size < 0) printf("Can not ftell file: \"%s\".\n", filename);
        return -1;
     }
   rewind(fp);
   file_data = (char *) calloc(1, file_size);
   if (!file_data)
     {
        fclose(fp);
        printf("Calloc failed\n");
        return -1;
     }
   int res = fread(file_data, 1, file_size, fp);
   if (!res)
     {
        free(file_data);
        file_data = NULL;
        if (!feof(fp)) printf("fread failed\n");
     }
   fclose(fp);
   if (file_data && buffer_out) *buffer_out = file_data;
   return file_size;
}

static void
_snapshot_load_from_fs(void *data, Evas_Object *fs EINA_UNUSED, void *ev)
{
   char *buffer = NULL;
   int size = _file_get(ev, &buffer);
   if (size <= 0) return;
   _snapshot_load(data, buffer, size);
}

static void
_obj_info_expand_request_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Elm_Object_Item *glit = event->info;
   elm_genlist_item_expanded_set(glit, EINA_TRUE);
}

static void
_obj_info_contract_request_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Elm_Object_Item *glit = event->info;
   elm_genlist_item_expanded_set(glit, EINA_FALSE);
}

static void
_obj_info_expanded_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Elm_Object_Item *glit = event->info;
   const Elm_Genlist_Item_Class *itc = elm_genlist_item_item_class_get(glit);
   if (itc == _obj_kl_info_itc)
     {
        Eolian_Debug_Class *kl = elm_object_item_data_get(glit);
        Eolian_Debug_Function *func;
        Eina_List *itr;
        EINA_LIST_FOREACH(kl->functions, itr, func)
          {
            Elm_Genlist_Item *glist =  elm_genlist_item_append(
                   event->object, _obj_func_info_itc, func, glit,
                   ELM_GENLIST_ITEM_NONE, NULL, NULL);
            elm_genlist_item_tooltip_content_cb_set(glist, _obj_info_tootip, func, NULL);
          }
     }
}

static void
_obj_info_contracted_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Elm_Object_Item *glit = event->info;
   elm_genlist_item_subitems_clear(glit);
}

static void
_eolian_type_to_string(const Eolian_Type *param_eolian_type, char *c_type)
{
   c_type[0] = '\0';
   if ((eolian_type_type_get(param_eolian_type) == EOLIAN_TYPE_REGULAR)//if its one of the base type or alias
         && !eolian_type_base_type_get(param_eolian_type))
     {
        sprintf(c_type, "%s", eolian_type_name_get(param_eolian_type));
     }
   else
     {
        const Eolian_Type *base = eolian_type_base_type_get(param_eolian_type);
        if ((eolian_type_type_get(base) == EOLIAN_TYPE_REGULAR) ||
              (eolian_type_type_get(base) == EOLIAN_TYPE_CLASS))
          {
             sprintf(c_type, "%s *", eolian_type_full_name_get(base));
          }
        else if (eolian_type_type_get(base) == EOLIAN_TYPE_VOID)
          {
             sprintf(c_type, "void *");
          }
#if 0
        else if (eolian_type_type_get(base) == EOLIAN_TYPE_ENUM)
          {
             sprintf(c_type, "%s",  eolian_type_full_name_get(param_eolian_type));
          }
        else if (eolian_type_type_get(base) == EOLIAN_TYPE_ALIAS)
          {
             sprintf(c_type, "%s", eolian_type_full_name_get(base));
          }
#endif
        else
          {
             sprintf(c_type, "%s *", eolian_type_is_const(base) ? "const " : "");
          }
     }
}

static int
_eolian_value_to_string(Eolian_Debug_Value *value, char *buffer, int max)
{
   switch(value->type)
     {
      case EOLIAN_DEBUG_STRING: return snprintf(buffer, max, "%s ",
                                      (char *)value->value.value);
      case EOLIAN_DEBUG_POINTER: return snprintf(buffer, max, "%p ",
                                       (void *)value->value.value);
      case EOLIAN_DEBUG_CHAR: return snprintf(buffer, max, "%c ",
                                    (char)value->value.value);
      case EOLIAN_DEBUG_INT: return snprintf(buffer, max, "%d ",
                                   (int)value->value.value);
      case EOLIAN_DEBUG_SHORT: return snprintf(buffer, max, "%u ",
                                     (unsigned int)value->value.value);
      case EOLIAN_DEBUG_DOUBLE: return snprintf(buffer, max, "%f ",
                                      (double)value->value.value);
      case EOLIAN_DEBUG_BOOLEAN: return snprintf(buffer, max, "%s ",
                                       (value->value.value ? "true" : "false"));
      case EOLIAN_DEBUG_LONG: return snprintf(buffer, max, "%ld ",
                                       (long)value->value.value);
      case EOLIAN_DEBUG_UINT: return snprintf(buffer, max, "%u ",
                                       (unsigned int)value->value.value);
      default: return snprintf(buffer, max, "%lX ", value->value.value);
     }
}

#define _MAX_LABEL 2000
static void
_func_params_to_string(Eolian_Debug_Function *func, char *buffer, Eina_Bool full)
{
   Eina_List *itr;
   int buffer_size = 0;
   buffer_size += snprintf(buffer + buffer_size,
         _MAX_LABEL - buffer_size,  "%s:  ",
         eolian_function_name_get(func->efunc));
   buffer[0] = toupper(buffer[0]);

   Eolian_Debug_Parameter *param;
   EINA_LIST_FOREACH(func->params, itr, param)
     {
        if(full)
          {
             char c_type[_MAX_LABEL];
             _eolian_type_to_string(eolian_parameter_type_get(param->etype), c_type);
             buffer_size += snprintf(buffer + buffer_size,
                   _MAX_LABEL - buffer_size, "%s ", c_type);
          }
        buffer_size += snprintf(buffer + buffer_size,
              _MAX_LABEL - buffer_size, "%s: ", eolian_parameter_name_get(param->etype));
        buffer_size += _eolian_value_to_string(&(param->value),
              buffer + buffer_size,  _MAX_LABEL - buffer_size);
        if(full)
           buffer_size += snprintf(buffer + buffer_size,
                 _MAX_LABEL - buffer_size, "(%lX) ", param->value.value.value);

     }
   if(func->params == NULL)
     {
        if(full)
          {
             char c_type[_MAX_LABEL];
             _eolian_type_to_string(func->ret.etype, c_type);
             buffer_size += snprintf(buffer + buffer_size,
                   _MAX_LABEL - buffer_size, "%s ", c_type);
          }
        buffer_size += snprintf(buffer + buffer_size,
              _MAX_LABEL - buffer_size, "%s: ", "");
        buffer_size += _eolian_value_to_string(&(func->ret.value),
              buffer + buffer_size,  _MAX_LABEL - buffer_size);
        if(full)
           buffer_size += snprintf(buffer + buffer_size,
                 _MAX_LABEL - buffer_size, "(%lX) ", func->ret.value.value.value);
     }
}

static Evas_Object *
_obj_info_tootip(void *data,
              Evas_Object *obj EINA_UNUSED,
              Evas_Object *tt,
              void *item   EINA_UNUSED)
{
   Evas_Object *l = elm_label_add(tt);
   char buffer[_MAX_LABEL];
   buffer[0] = '\0';
   _func_params_to_string(data, buffer, EINA_TRUE);
   elm_object_text_set(l, buffer);
   elm_label_line_wrap_set(l, ELM_WRAP_NONE);

   return l;
}

static char *
_obj_kl_info_item_label_get(void *data, Evas_Object *obj EINA_UNUSED,
      const char *part EINA_UNUSED)
{
   Eolian_Debug_Class *kl = data;
   return strdup(eolian_class_full_name_get(kl->ekl));
}

static char *
_obj_func_info_item_label_get(void *data, Evas_Object *obj EINA_UNUSED,
      const char *part EINA_UNUSED)
{
   char buffer[_MAX_LABEL];
   buffer[0] = '\0';
   Eolian_Debug_Function *func = data;
   _func_params_to_string(func, buffer, EINA_FALSE);
   return strdup(buffer);
}
#undef _MAX_LABEL

static void
_obj_info_realize(Clouseau_Extension *ext, Eolian_Debug_Object_Information *e_info)
{
   Instance *inst = ext->data;
   Eolian_Debug_Class *kl;
   Eina_List *kl_itr;

   elm_genlist_clear(inst->wdgs->object_infos_list);
   EINA_LIST_FOREACH(e_info->classes, kl_itr, kl)
     {
        Elm_Object_Item  *glg = elm_genlist_item_append(
              inst->wdgs->object_infos_list, _obj_kl_info_itc,
              kl, NULL, ELM_GENLIST_ITEM_TREE, NULL, NULL);
        elm_genlist_item_expanded_set(glg, EINA_FALSE);
     }
}

static Eina_Debug_Error
_obj_info_get(Eina_Debug_Session *session, int src, void *buffer, int size)
{
   Clouseau_Extension *ext = NULL;
   Instance *inst = NULL;
   if (src == -1)
     {
        ext = (Clouseau_Extension *)session;
        session = NULL;
     }
   else
     {
        ext = eina_debug_session_data_get(session);
     }
   inst = ext->data;
   Eolian_Debug_Object_Information *e_info =
      eolian_debug_object_information_decode(buffer, size);
   Obj_Info *o_info = eina_hash_find(inst->objs_hash, &(e_info->obj));
   if (!o_info) return EINA_DEBUG_OK;

   if (o_info->eolian_info)
      eolian_debug_object_information_free(o_info->eolian_info);
   o_info->eolian_info = e_info;

   if (o_info == inst->selected_obj) _obj_info_realize(ext, e_info);

   return EINA_DEBUG_OK;
}

static void
_objs_expand_request_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Elm_Object_Item *glit = event->info;
   elm_genlist_item_expanded_set(glit, EINA_TRUE);
}

static void
_objs_contract_request_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Elm_Object_Item *glit = event->info;
   elm_genlist_item_expanded_set(glit, EINA_FALSE);
}

static void
_objs_sel_cb(void *data EINA_UNUSED, Evas_Object *obj, void *event_info)
{
   Clouseau_Extension *ext = _ext_get(obj);
   if (!ext) return;
   Instance *inst = ext->data;
   if (!ext->app_id) return;
   Elm_Object_Item *glit = event_info;
   Obj_Info *info = elm_object_item_data_get(glit);

   inst->selected_obj = info;

   elm_genlist_clear(inst->wdgs->object_infos_list);
   if (_config->highlight)
     {
        eina_debug_session_send_to_thread(ext->session, ext->app_id, info->thread_id,
              _obj_highlight_op, &(info->obj), sizeof(uint64_t));
     }
   eina_debug_session_send_to_thread(ext->session, ext->app_id, info->thread_id,
         _obj_info_op, &(info->obj), sizeof(uint64_t));
   if (info->eolian_info) _obj_info_realize(ext, info->eolian_info);
}

static void
_objs_expanded_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Eina_List *itr;
   Clouseau_Extension *ext = _ext_get(event->object);
   Elm_Object_Item *glit = event->info;
   Obj_Info *info = elm_object_item_data_get(glit), *it_data;
   if (!ext) return;
   EINA_LIST_FOREACH(info->children, itr, it_data)
     {
        it_data->glitem = elm_genlist_item_append(event->object, _objs_itc,
              it_data, glit,
              it_data->children ? ELM_GENLIST_ITEM_TREE : ELM_GENLIST_ITEM_NONE,
              _objs_sel_cb, ext);
        elm_genlist_item_expanded_set(it_data->glitem, EINA_FALSE);
        efl_wref_add(it_data->glitem, &(it_data->glitem));
     }
}

static void
_objs_contracted_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
   Elm_Object_Item *glit = event->info;
   elm_genlist_item_subitems_clear(glit);
}

static char *
_objs_item_label_get(void *data, Evas_Object *obj,
      const char *part EINA_UNUSED)
{
   char buf[128];
   Clouseau_Extension *ext = _ext_get(obj);
   Instance *inst = ext->data;
   Obj_Info *oinfo = data;
   Class_Info *kinfo = eina_hash_find(inst->classes_hash_by_id, &(oinfo->kl_id));
   sprintf(buf, "%s %lX", kinfo ? kinfo->name : "(Unknown)", oinfo->obj);
   return strdup(buf);
}

static Eina_Debug_Error
_win_screenshot_get(Eina_Debug_Session *session EINA_UNUSED, int src EINA_UNUSED,
      void *buffer, int size)
{
   Clouseau_Extension *ext = eina_debug_session_data_get(session);
   Instance *inst = ext->data;
   Evas_Debug_Screenshot *s = evas_debug_screenshot_decode(buffer, size);
   if (!s) return EINA_DEBUG_ERROR;
   Obj_Info *info = eina_hash_find(inst->objs_hash, &(s->obj));
   if (!info) return EINA_DEBUG_OK;
   info->screenshots = eina_list_append(info->screenshots, s);
   inst->screenshots = eina_list_append(inst->screenshots, s);
   if (info->glitem) elm_genlist_item_update(info->glitem);
   return EINA_DEBUG_OK;
}

void
take_screenshot_button_clicked(void *data EINA_UNUSED, const Efl_Event *event)
{
   Obj_Info *info = efl_key_data_get(event->object, "__info_node");
   Clouseau_Extension *ext = _ext_get(event->object);
   if (!ext || !ext->app_id) return;

   eina_debug_session_send_to_thread(ext->session, ext->app_id, info->thread_id,
         _win_screenshot_op, &(info->obj), sizeof(uint64_t));
}

static void
_screenshot_display(Evas_Debug_Screenshot *s)
{
   Gui_Show_Screenshot_Win_Widgets *wdgs = gui_show_screenshot_win_create(NULL);

   Eo *img = evas_object_image_filled_add(evas_object_evas_get(wdgs->win));

   evas_object_size_hint_min_set(img, s->w, s->h);
   elm_object_content_set(wdgs->bg, img);

   evas_object_image_colorspace_set(img, EVAS_COLORSPACE_ARGB8888);
   evas_object_image_alpha_set(img, EINA_FALSE);
   evas_object_image_size_set(img, s->w, s->h);
   evas_object_image_data_copy_set(img, s->img);
   evas_object_image_data_update_add(img, 0, 0, s->w, s->h);
   evas_object_show(img);

   evas_object_resize(wdgs->win, s->w, s->h);
}

static void
_menu_screenshot_selected(void *data,
      Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
   _screenshot_display(data);
}

void
show_screenshot_button_clicked(void *data EINA_UNUSED, const Efl_Event *event)
{
   Eo *bt = event->object;
   Obj_Info *info = efl_key_data_get(event->object, "__info_node");
   if (eina_list_count(info->screenshots) == 1)
     {
        _screenshot_display(eina_list_data_get(info->screenshots));
     }
   else
     {
        Eina_List *itr;
        Evas_Debug_Screenshot *s;
        int x = 0, y = 0, h = 0;
        Clouseau_Extension *ext = _ext_get(bt);
        Instance *inst = ext->data;

        if (info->screenshots_menu) efl_del(info->screenshots_menu);
        info->screenshots_menu = elm_menu_add(inst->wdgs->main);
        efl_wref_add(info->screenshots_menu, &info->screenshots_menu);

        efl_gfx_position_get(bt, &x, &y);
        efl_gfx_size_get(bt, NULL, &h);
        elm_menu_move(info->screenshots_menu, x, y + h);
        efl_gfx_visible_set(info->screenshots_menu, EINA_TRUE);
        EINA_LIST_FOREACH(info->screenshots, itr, s)
          {
             char str[200];
             sprintf(str, "%.2d:%.2d:%.2d",
                   s->tm_hour, s->tm_min, s->tm_sec);
             elm_menu_item_add(info->screenshots_menu,
                   NULL, NULL, str, _menu_screenshot_selected, s);
          }
     }
}

static void *
_eoids_request_prepare(Clouseau_Extension *ext, int *size)
{
   uint64_t obj_kl = 0, canvas_kl = 0;
   Instance *inst = ext->data;
   Class_Info *info = eina_hash_find(inst->classes_hash_by_name,
         _config->wdgs_show_type == 0 ? "Efl.Canvas.Object" : "Elm.Widget");
   if (info) obj_kl = info->id;
   info = eina_hash_find(inst->classes_hash_by_name, "Efl.Canvas");
   if (info) canvas_kl = info->id;
   return eo_debug_eoids_request_prepare(size, obj_kl, canvas_kl, NULL);
}

static Eina_Debug_Error
_snapshot_done_cb(Eina_Debug_Session *session, int src EINA_UNUSED,
      void *buffer EINA_UNUSED, int size EINA_UNUSED)
{
   Clouseau_Extension *ext = eina_debug_session_data_get(session);
   Instance *inst = ext->data;
   Snapshot *s = inst->snapshot;
   if (!s) return EINA_DEBUG_OK;
   _snapshot_save(ext);
   free(s->buffer);
   free(s);
   inst->snapshot = NULL;
   ext->ui_freeze_cb(ext, EINA_FALSE);
   return EINA_DEBUG_OK;
}

static void
_snapshot_do(void *data, Evas_Object *fs EINA_UNUSED, void *ev)
{
   void *buf;
   Clouseau_Extension *ext = data;
   int size;
   if (!ext || !ext->app_id) return;
   Instance *inst = ext->data;
   ext->ui_freeze_cb(ext, EINA_TRUE);
   inst->snapshot = calloc(1, sizeof(Snapshot));
   inst->snapshot->out_file = eina_stringshare_add(ev);
   buf = _eoids_request_prepare(ext, &size);
   eina_debug_session_send(ext->session, ext->app_id, _snapshot_do_op, buf, size);
   free(buf);
}

void
objs_type_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
   int type = (uintptr_t) data;
   Clouseau_Extension *ext = _ext_get(obj);
   Instance *inst = ext->data;
   elm_radio_value_set(inst->wdgs->objs_type_radio, type);
   _config->wdgs_show_type = type;
   _config_save(ext);
}

void
highlight_changed(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
   Clouseau_Extension *ext = _ext_get(obj);
   Instance *inst = ext->data;
   _config->highlight = !_config->highlight;
   elm_check_state_set(inst->wdgs->highlight_ck, _config->highlight);
   _config_save(ext);
}

static Evas_Object *
_objs_item_content_get(void *data, Evas_Object *obj, const char *part)
{
   static uint64_t canvas_id = 0;
   Obj_Info *info = data;
   Clouseau_Extension *ext = _ext_get(obj);
   if (!ext) return NULL;
   Instance *inst = ext->data;
   if (!canvas_id)
     {
        Class_Info *kl_info = eina_hash_find(inst->classes_hash_by_name, "Evas.Canvas");
        if (kl_info) canvas_id = kl_info->id;
     }
   if (info->kl_id == canvas_id && !strcmp(part, "elm.swallow.end"))
   {
      Eo *box = elm_box_add(obj);
      evas_object_size_hint_weight_set(box, 1.000000, 1.000000);
      elm_box_horizontal_set(box, EINA_TRUE);
      efl_gfx_visible_set(box, EINA_TRUE);

      if (info->screenshots)
        {
           Gui_Show_Screenshot_Button_Widgets *swdgs = gui_show_screenshot_button_create(box);
           if (eina_list_count(info->screenshots) == 1)
             {
                elm_object_tooltip_text_set(swdgs->bt, "Show screenshot");
             }
           else
             {
                elm_object_tooltip_text_set(swdgs->bt, "List screenshots");
             }
           efl_key_data_set(swdgs->bt, "__info_node", info);
           efl_key_data_set(swdgs->bt, "__extension", ext);
           elm_box_pack_end(box, swdgs->bt);
        }

      if (ext->session)
        {
           Gui_Take_Screenshot_Button_Widgets *twdgs = gui_take_screenshot_button_create(box);
           elm_object_tooltip_text_set(twdgs->bt, "Take screenshot");
           efl_key_data_set(twdgs->bt, "__info_node", info);
           efl_key_data_set(twdgs->bt, "__extension", ext);
           elm_box_pack_end(box, twdgs->bt);
        }

      return box;
   }
   return NULL;
}

static Eina_Debug_Error
_module_initted_cb(Eina_Debug_Session *session, int src, void *buffer, int size)
{
   Clouseau_Extension *ext = eina_debug_session_data_get(session);
   if (size <= 0) return EINA_DEBUG_ERROR;
   if (!ext) return EINA_DEBUG_OK;
   Instance *inst = ext->data;
   Eina_Bool ret = !!((char *)buffer)[size - 1];

   if (!ret)
     {
        printf("Error loading module %s in the target\n", (char *)buffer);
     }
   if (!strcmp(buffer, "eo")) inst->eo_init_done = ret;
   if (!strcmp(buffer, "eolian")) inst->eolian_init_done = ret;
   if (!strcmp(buffer, "evas")) inst->evas_init_done = ret;
   if (!strcmp(buffer, "clouseau")) inst->clouseau_init_done = ret;

   if (!inst->eo_init_done)
     {
        eina_debug_session_send(session, src, _module_init_op, "eo", 3);
        return EINA_DEBUG_OK;
     }
   if (!inst->eolian_init_done)
     {
        eina_debug_session_send(session, src, _module_init_op, "eolian", 7);
        return EINA_DEBUG_OK;
     }
   if (!inst->evas_init_done)
     {
        eina_debug_session_send(session, src, _module_init_op, "evas", 5);
        return EINA_DEBUG_OK;
     }
   if (!inst->clouseau_init_done)
     {
        eina_debug_session_send(session, src, _module_init_op, "clouseau", 9);
        return EINA_DEBUG_OK;
     }
   eina_debug_session_send(session, src, _klids_get_op, NULL, 0);
   return EINA_DEBUG_OK;
}

static void
_klid_walk(void *data, uint64_t kl, char *name)
{
   Instance *inst = data;
   Class_Info *info = calloc(1, sizeof(*info));
   info->id = kl;
   info->name = eina_stringshare_add(name);
   eina_hash_add(inst->classes_hash_by_id, &(info->id), info);
   eina_hash_add(inst->classes_hash_by_name, info->name, info);
}

static Eina_Debug_Error
_klids_get(Eina_Debug_Session *session, int src, void *buffer, int size)
{
   uint64_t obj_kl = 0, canvas_kl = 0;
   void *buf;
   Clouseau_Extension *ext = NULL;
   Instance *inst = NULL;
   if (src == -1)
     {
        ext = (Clouseau_Extension *)session;
        session = NULL;
     }
   else
     {
        ext = eina_debug_session_data_get(session);
     }
   inst = ext->data;
   eo_debug_klids_extract(buffer, size, _klid_walk, inst);
   Class_Info *info = eina_hash_find(inst->classes_hash_by_name,
         _config->wdgs_show_type == 0 ? "Efl.Canvas.Object" : "Elm.Widget");
   if (info) obj_kl = info->id;
   info = eina_hash_find(inst->classes_hash_by_name, "Efl.Canvas");
   if (info) canvas_kl = info->id;
   buf = eo_debug_eoids_request_prepare(&size, obj_kl, canvas_kl, NULL);
   eina_debug_session_send_to_thread(session, src, 0xFFFFFFFF, _eoids_get_op, buf, size);
   free(buf);
   return EINA_DEBUG_OK;
}

static void
_eoid_walk(void *data, uint64_t obj, uint64_t kl_id, uint64_t parent)
{
   Eina_List **objs = data;
   Obj_Info *info = calloc(1, sizeof(*info));
   info->obj = obj;
   info->kl_id = kl_id;
   info->parent = parent;
   *objs = eina_list_append(*objs, info);
}

static Eina_Debug_Error
_eoids_get(Eina_Debug_Session *session, int src, void *buffer, int size)
{
   Eina_List *objs = NULL, *l;
   Clouseau_Extension *ext = NULL;
   Instance *inst = NULL;
   Obj_Info *info;
   int thread_id;
   if (src == -1)
     {
        ext = (Clouseau_Extension *)session;
        session = NULL;
     }
   else
     {
        ext = eina_debug_session_data_get(session);
     }
   inst = ext->data;

   eo_debug_eoids_extract(buffer, size, _eoid_walk, &objs, &thread_id);

   EINA_LIST_FOREACH(objs, l, info)
     {
        info->thread_id = thread_id;
        eina_hash_add(inst->objs_hash, &(info->obj), info);
     }

   /* Fill children lists */
   EINA_LIST_FREE(objs, info)
     {
        Obj_Info *info_parent =  eina_hash_find(inst->objs_hash, &(info->parent));

        if (info_parent)
           info_parent->children = eina_list_append(info_parent->children, info);
        else
           inst->objs_list_tree = eina_list_append(inst->objs_list_tree, info);
     }

   /* Add to Genlist */
   EINA_LIST_FOREACH(inst->objs_list_tree, l, info)
     {
        if (!info->glitem)
          {
             info->glitem = elm_genlist_item_append(
                   inst->wdgs->objects_list, _objs_itc, info, NULL,
                   info->children ? ELM_GENLIST_ITEM_TREE : ELM_GENLIST_ITEM_NONE,
                   _objs_sel_cb, ext);
             efl_wref_add(info->glitem, &(info->glitem));
             if (info->children)
                elm_genlist_item_expanded_set(info->glitem, EINA_FALSE);
          }
     }

   return EINA_DEBUG_OK;
}

static void
_item_realize(Instance *inst, Obj_Info *info)
{
   if (info->parent)
      {
         Obj_Info *pinfo =  eina_hash_find(inst->objs_hash, &(info->parent));
         if (pinfo)
           {
              if (!pinfo->glitem) _item_realize(inst, pinfo);
              elm_genlist_item_expanded_set(pinfo->glitem, EINA_TRUE);
           }
      }
}

static void
_jump_entry_changed(void *data, const Efl_Event *event)
{
   Eo *en = event->object;
   Eo *inwin = data;
   const char *ptr = elm_entry_entry_get(en);
   Clouseau_Extension *ext = efl_key_data_get(en, "__extension");
   Instance *inst = ext->data;
   uint64_t id = 0;
   Eina_Bool err = EINA_FALSE;

   printf("Ptr %s\n", ptr);
   while (*ptr && !err)
     {
        char c = *ptr;
        id <<= 4;
        if (c >= '0' && c <= '9') id |= (*ptr - '0');
        else if (c >= 'a' && c <= 'f') id |= (*ptr - 'a' + 0xA);
        else if (c >= 'A' && c <= 'F') id |= (*ptr - 'A' + 0xA);
        else err = EINA_TRUE;
        ptr++;
     }
   efl_del(inwin);
   if (!err)
     {
        Obj_Info *info =  eina_hash_find(inst->objs_hash, &id);
        if (!info) return;
        if (!info->glitem) _item_realize(inst, info);
        elm_genlist_item_show(info->glitem, ELM_GENLIST_ITEM_SCROLLTO_MIDDLE);
        elm_genlist_item_selected_set(info->glitem, EINA_TRUE);
     }
}

void
jump_to_ptr_inwin_show(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
   Clouseau_Extension *ext = _ext_get(obj);
   Eo *inwin = ext->inwin_create_cb();
   Eo *entry = elm_entry_add(inwin);
   elm_entry_scrollable_set(entry, EINA_TRUE);
   elm_entry_single_line_set(entry, EINA_TRUE);
   elm_object_part_text_set(entry, "guide", "Jump To Pointer");
   efl_event_callback_add(entry, ELM_ENTRY_EVENT_ACTIVATED, _jump_entry_changed, inwin);
   efl_key_data_set(entry, "__extension", ext);
   evas_object_show(entry);
   elm_win_inwin_content_set(inwin, entry);
   elm_win_inwin_activate(inwin);
}

static void
_inwin_del(void *data, Evas_Object *obj EINA_UNUSED, void *ev EINA_UNUSED)
{
   Eo *inwin = data;
   efl_del(inwin);
}

static void
_fs_activate(Clouseau_Extension *ext, Eina_Bool is_save)
{
   Eo *inwin = ext->inwin_create_cb();
   Eo *fs = elm_fileselector_add(inwin);

   elm_fileselector_is_save_set(fs, is_save);
   elm_fileselector_path_set(fs, getenv("HOME"));
   evas_object_size_hint_weight_set
      (fs, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
   evas_object_size_hint_align_set(fs, EVAS_HINT_FILL, EVAS_HINT_FILL);
   evas_object_smart_callback_add(fs, "done", _inwin_del, inwin);
   evas_object_smart_callback_add(fs, "done",
         is_save?_snapshot_do:_snapshot_load_from_fs, ext);
   evas_object_show(fs);

   elm_win_inwin_content_set(inwin, fs);
   elm_win_inwin_activate(inwin);
}

void
reload_perform(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
   Clouseau_Extension *ext = _ext_get(obj);
   if (ext->session)
     {
        /* Reload */
        if (!ext->app_id) return;
        _app_changed(ext);
     }
}

void
save_load_perform(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
   Clouseau_Extension *ext = _ext_get(obj);
   if (ext->session) _fs_activate(ext, EINA_TRUE);
   else _fs_activate(ext, EINA_FALSE);
}

static Eo *
_ui_get(Clouseau_Extension *ext, Eo *parent)
{
   Instance *inst = ext->data;
   inst->wdgs = gui_win_create(parent);

   efl_key_data_set(inst->wdgs->main, "__extension", ext);
   efl_key_data_set(inst->wdgs->tb, "__extension", ext);

   elm_radio_value_set(inst->wdgs->objs_type_radio, _config->wdgs_show_type);
   elm_check_state_set(inst->wdgs->highlight_ck, _config->highlight);
   //Init objects Genlist
   if (!_objs_itc)
     {
        _objs_itc = elm_genlist_item_class_new();
        _objs_itc->item_style = "default";
        _objs_itc->func.text_get = _objs_item_label_get;
        _objs_itc->func.content_get = _objs_item_content_get;
     }
   efl_event_callback_add(inst->wdgs->objects_list, ELM_GENLIST_EVENT_EXPAND_REQUEST, _objs_expand_request_cb, NULL);
   efl_event_callback_add(inst->wdgs->objects_list, ELM_GENLIST_EVENT_CONTRACT_REQUEST, _objs_contract_request_cb, NULL);
   efl_event_callback_add(inst->wdgs->objects_list, ELM_GENLIST_EVENT_EXPANDED, _objs_expanded_cb, NULL);
   efl_event_callback_add(inst->wdgs->objects_list, ELM_GENLIST_EVENT_CONTRACTED, _objs_contracted_cb, NULL);

   //Init object class info itc
   if (!_obj_kl_info_itc)
     {
        _obj_kl_info_itc = elm_genlist_item_class_new();
        _obj_kl_info_itc->item_style = "default";
        _obj_kl_info_itc->func.text_get = _obj_kl_info_item_label_get;
     }
   //Init object function info itc
   if (!_obj_func_info_itc)
     {
        _obj_func_info_itc = elm_genlist_item_class_new();
        _obj_func_info_itc->item_style = "default";
        _obj_func_info_itc->func.text_get = _obj_func_info_item_label_get;
     }
   efl_event_callback_add(inst->wdgs->object_infos_list, ELM_GENLIST_EVENT_EXPAND_REQUEST, _obj_info_expand_request_cb, NULL);
   efl_event_callback_add(inst->wdgs->object_infos_list, ELM_GENLIST_EVENT_CONTRACT_REQUEST, _obj_info_contract_request_cb, NULL);
   efl_event_callback_add(inst->wdgs->object_infos_list, ELM_GENLIST_EVENT_EXPANDED, _obj_info_expanded_cb, NULL);
   efl_event_callback_add(inst->wdgs->object_infos_list, ELM_GENLIST_EVENT_CONTRACTED, _obj_info_contracted_cb, NULL);
   return inst->wdgs->main;
}

EAPI const char *
extension_name_get()
{
   return "Objects introspection";
}

EAPI Eina_Bool
extension_start(Clouseau_Extension *ext, Eo *parent)
{
   Instance *inst = calloc(1, sizeof(*inst));

   eina_init();
   eolian_init();

   ext->data = inst;
   ext->session_changed_cb = _session_changed;
   ext->app_changed_cb = _app_changed;
   ext->import_data_cb = _snapshot_load;

   inst->classes_hash_by_id = eina_hash_pointer_new(NULL);
   inst->classes_hash_by_name = eina_hash_string_small_new(NULL);

   inst->objs_hash = eina_hash_pointer_new(NULL);

   eolian_directory_scan(EOLIAN_EO_DIR);

   _config_load(ext);

   ext->ui_object = _ui_get(ext, parent);
   return !!ext->ui_object;
}

EAPI Eina_Bool
extension_stop(Clouseau_Extension *ext)
{
   Instance *inst = ext->data;

   efl_del(ext->ui_object);

   _objs_tree_free(inst->objs_list_tree);

   eina_hash_free(inst->objs_hash);

   eina_hash_free(inst->classes_hash_by_name);
   eina_hash_free(inst->classes_hash_by_id);

   free(inst);

   eolian_shutdown();
   eina_shutdown();

   return EINA_TRUE;
}