src/edje_externals/elm.c

   1 #include "Elementary.h"
   2 #include "private.h"
   3
   4 int _elm_ext_log_dom = -1;
   5
   6 static int init_count = 0;
   7
   8 void
   9 external_elm_init(void)
  10 {
  11    int argc = 0;
  12    char **argv = NULL;
  13
  14    init_count++;
  15    DBG("elm_real_init\n");
  16    if (init_count > 1) return;
  17    ecore_app_args_get(&argc, &argv);
  18    elm_init(argc, argv);
  19 }
  20
  21 static void
  22 external_elm_shutdown(void)
  23 {
  24    init_count--;
  25    DBG("elm_real_shutdown\n");
  26    if (init_count > 0) return;
  27    elm_shutdown();
  28 }
  29
  30 static void
  31 _external_obj_del(void *data __UNUSED__, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
  32 {
  33    evas_object_event_callback_del(obj, EVAS_CALLBACK_DEL,
  34                                   _external_obj_del);
  35    external_elm_shutdown();
  36 }
  37
  38 void
  39 external_signal(void *data __UNUSED__, Evas_Object *obj, const char *sig, const char *source)
  40 {
  41    char *_signal = strdup(sig);
  42    char *p = _signal;
  43    Evas_Object *content;
  44
  45    while ((*p!='\0') && (*p!=']'))
  46      p++;
  47
  48
  49    if ((*p=='\0') || (*(p+1)!=':'))
  50      {
  51         ERR("Invalid External Signal received: '%s' '%s'\n", sig, source);
  52         free(_signal);
  53         return ;
  54      }
  55
  56    *p = '\0';
  57    p+=2; //jump ']' and ':'
  58
  59    Edje_External_Type *type = evas_object_data_get(obj, "Edje_External_Type");
  60    if (!type->content_get)
  61      {
  62         ERR("external type '%s' from module '%s' does not provide content_get()",
  63             type->module_name, type->module);
  64         free(_signal);
  65         return ;
  66      }
  67
  68    content = type->content_get(type->data, obj, _signal);
  69    free(_signal);
  70    if (content)
  71      edje_object_signal_emit(content, sig + (p - _signal), source);
  72 }
  73
  74 const char *
  75 external_translate(void *data __UNUSED__, const char *orig)
  76 {
  77    // in future, mark all params as translatable and use dgettext()
  78    // with "elementary" text domain here.
  79    return orig;
  80 }
  81
  82 typedef struct {
  83    const char *emission;
  84    const char *source;
  85    Evas_Object *edje;
  86 } Elm_External_Signals_Proxy_Context;
  87
  88 static void
  89 _external_signal_proxy_free_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
  90 {
  91    Elm_External_Signals_Proxy_Context *ctxt = data;
  92    free(ctxt);
  93 }
  94
  95 static void
  96 _external_signal_proxy_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
  97 {
  98    Elm_External_Signals_Proxy_Context *ctxt = data;
  99    // TODO: Is it worth to check Evas_Smart_Cb_Description and do something
 100    // TODO: with event_info given its description?
 101    edje_object_signal_emit(ctxt->edje, ctxt->emission, ctxt->source);
 102 }
 103
 104 Eina_Bool
 105 external_common_param_get(void *data __UNUSED__, const Evas_Object *obj, Edje_External_Param *param)
 106 {
 107    if (!strcmp(param->name, "style"))
 108      {
 109         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 110           {
 111              param->s = elm_object_style_get(obj);
 112              return EINA_TRUE;
 113           }
 114      }
 115    else if (!strcmp(param->name, "disabled"))
 116      {
 117         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 118           {
 119              param->i = elm_object_disabled_get(obj);
 120              return EINA_TRUE;
 121           }
 122      }
 123    return EINA_FALSE;
 124 }
 125
 126 Eina_Bool
 127 external_common_param_set(void *data __UNUSED__, Evas_Object *obj, const Edje_External_Param *param)
 128 {
 129    if (!strcmp(param->name, "style"))
 130      {
 131          if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 132            {
 133               elm_object_style_set(obj, param->s);
 134               return EINA_TRUE;
 135            }
 136      }
 137    else if (!strcmp(param->name, "disabled"))
 138      {
 139          if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 140            {
 141               elm_object_disabled_set(obj, param->i);
 142               return EINA_TRUE;
 143            }
 144      }
 145    return EINA_FALSE;
 146 }
 147
 148 void
 149 external_signals_proxy(Evas_Object *obj, Evas_Object *edje, const char *part_name)
 150 {
 151    const Evas_Smart_Cb_Description **cls_descs, **inst_descs;
 152    unsigned int cls_count, inst_count, total;
 153    Elm_External_Signals_Proxy_Context *ctxt;
 154
 155    evas_object_smart_callbacks_descriptions_get
 156      (obj, &cls_descs, &cls_count, &inst_descs, &inst_count);
 157
 158    total = cls_count + inst_count;
 159    if (!total) return;
 160    ctxt = malloc(sizeof(Elm_External_Signals_Proxy_Context) * total);
 161    if (!ctxt) return;
 162    evas_object_event_callback_add
 163      (obj, EVAS_CALLBACK_FREE, _external_signal_proxy_free_cb, ctxt);
 164
 165    for (; cls_count > 0; cls_count--,  cls_descs++, ctxt++)
 166      {
 167         const Evas_Smart_Cb_Description *d = *cls_descs;
 168         ctxt->emission = d->name;
 169         ctxt->source = part_name;
 170         ctxt->edje = edje;
 171         evas_object_smart_callback_add
 172           (obj, d->name, _external_signal_proxy_cb, ctxt);
 173      }
 174
 175    for (; inst_count > 0; inst_count--,  inst_descs++, ctxt++)
 176      {
 177         const Evas_Smart_Cb_Description *d = *inst_descs;
 178         ctxt->emission = d->name;
 179         ctxt->source = part_name;
 180         ctxt->edje = edje;
 181         evas_object_smart_callback_add
 182           (obj, d->name, _external_signal_proxy_cb, ctxt);
 183      }
 184    evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
 185                                   _external_obj_del, NULL);
 186 }
 187
 188 void
 189 external_common_params_parse(void *mem, void *data __UNUSED__, Evas_Object *obj __UNUSED__, const Eina_List *params)
 190 {
 191    Elm_Params *p;
 192    const Eina_List *l;
 193    Edje_External_Param *param;
 194
 195    p = mem;
 196    EINA_LIST_FOREACH(params, l, param)
 197      {
 198         if (!strcmp(param->name, "style"))
 199           p->style = eina_stringshare_add(param->s);
 200         else if (!strcmp(param->name, "disabled"))
 201           {
 202              p->disabled = param->i;
 203              p->disabled_exists = EINA_TRUE;
 204           }
 205      }
 206 }
 207
 208 void
 209 external_common_state_set(void *data __UNUSED__, Evas_Object *obj, const void *from_params, const void *to_params, float pos __UNUSED__)
 210 {
 211    const Elm_Params *p;
 212    if (to_params) p = to_params;
 213    else if (from_params) p = from_params;
 214    else return;
 215
 216    if (p->style)
 217       elm_object_style_set(obj, p->style);
 218    if (p->disabled_exists)
 219      elm_object_disabled_set(obj, p->disabled);
 220 }
 221
 222 Evas_Object *
 223 external_common_param_icon_get(Evas_Object *obj, const Edje_External_Param *p)
 224 {
 225    Evas_Object *edje, *parent_widget, *icon;
 226    const char *file;
 227
 228    if ((!p) || (!p->s) || (p->type != EDJE_EXTERNAL_PARAM_TYPE_STRING))
 229        return NULL;
 230
 231    edje = evas_object_smart_parent_get(obj);
 232    edje_object_file_get(edje, &file, NULL);
 233
 234    parent_widget = elm_widget_parent_widget_get(obj);
 235    if (!parent_widget)
 236      parent_widget = edje;
 237    icon = elm_icon_add(parent_widget);
 238
 239    if (elm_icon_file_set(icon, file, p->s))
 240      return icon;
 241    if (elm_icon_standard_set(icon, p->s))
 242      return icon;
 243
 244    evas_object_del(icon);
 245    return NULL;
 246 }
 247
 248 void
 249 external_common_icon_param_parse(Evas_Object **icon, Evas_Object *obj, const Eina_List *params)
 250 {
 251    Edje_External_Param *p = edje_external_param_find(params, "icon");
 252    *icon = external_common_param_icon_get(obj, p);
 253 }
 254
 255 Evas_Object *
 256 external_common_param_edje_object_get(Evas_Object *obj, const Edje_External_Param *p)
 257 {
 258    Evas_Object *edje, *parent_widget, *ret;
 259    const char *file;
 260
 261    if ((!p) || (!p->s) || (p->type != EDJE_EXTERNAL_PARAM_TYPE_STRING))
 262        return NULL;
 263
 264    edje = evas_object_smart_parent_get(obj);
 265    edje_object_file_get(edje, &file, NULL);
 266
 267    parent_widget = elm_widget_parent_widget_get(obj);
 268    if (!parent_widget)
 269      parent_widget = edje;
 270
 271    ret = edje_object_add(evas_object_evas_get(parent_widget));
 272
 273    if (edje_object_file_set(ret, file, p->s))
 274      return ret;
 275
 276    evas_object_del(ret);
 277    return NULL;
 278 }
 279
 280 void
 281 external_common_params_free(void *params)
 282 {
 283    Elm_Params *p = params;
 284    if (p->style)
 285      eina_stringshare_del(p->style);
 286 }
 287
 288 #define DEFINE_TYPE(type_name) \
 289   extern const Edje_External_Type external_##type_name##_type;
 290 #include "modules.inc"
 291 #undef DEFINE_TYPE
 292
 293 static Edje_External_Type_Info elm_external_types[] =
 294 {
 295 #define DEFINE_TYPE(type_name)              \
 296   {"elm/"#type_name, &external_##type_name##_type},
 297 #include "modules.inc"
 298 #undef DEFINE_TYPE
 299    {NULL, NULL}
 300 };
 301
 302 static Eina_Bool
 303 elm_mod_init(void)
 304 {
 305    _elm_ext_log_dom = eina_log_domain_register("elm-externals", EINA_COLOR_LIGHTBLUE);
 306    edje_external_type_array_register(elm_external_types);
 307    return EINA_TRUE;
 308 }
 309
 310 static void
 311 elm_mod_shutdown(void)
 312 {
 313    edje_external_type_array_unregister(elm_external_types);
 314    if (_elm_ext_log_dom >= 0) eina_log_domain_unregister(_elm_ext_log_dom);
 315    _elm_ext_log_dom = -1;
 316 }
 317
 318 EINA_MODULE_INIT(elm_mod_init);
 319 EINA_MODULE_SHUTDOWN(elm_mod_shutdown);