src/edje_externals/elm_notify.c

   1 #include "private.h"
   2 #include <assert.h>
   3
   4
   5 typedef struct _Elm_Params_Notify Elm_Params_Notify;
   6
   7 struct _Elm_Params_Notify {
   8         Elm_Params base;
   9         Evas_Object *content; /* part name whose obj is to be set as content */
  10         Eina_Bool repeat_events_exists;
  11         Eina_Bool repeat_events;
  12         Eina_Bool timer_init;
  13         Eina_Bool timeout_exists;
  14         int timeout;
  15
  16         const char *orient;
  17 };
  18
  19
  20 static const char *orients[] = {
  21                 "top",
  22                 "center",
  23                 "bottom",
  24                 "left",
  25                 "right",
  26                 "top_left",
  27                 "top_right",
  28                 "bottom_left",
  29                 "bottom_right",
  30                 NULL
  31 };
  32
  33 static Elm_Notify_Orient _orient_get(const char *orient)
  34 {
  35    unsigned int i;
  36
  37    assert(sizeof(orients)/sizeof(orients[0]) ==
  38           ELM_NOTIFY_ORIENT_LAST + 1);
  39
  40    for (i = 0; i < sizeof(orients); i++)
  41      if (strcmp(orient, orients[i]) == 0) return i;
  42
  43    return ELM_NOTIFY_ORIENT_LAST;
  44 }
  45
  46 static void external_notify_state_set(void *data __UNUSED__,
  47                 Evas_Object *obj, const void *from_params,
  48                 const void *to_params, float pos __UNUSED__)
  49 {
  50         const Elm_Params_Notify *p;
  51
  52         if (to_params) p = to_params;
  53         else if (from_params) p = from_params;
  54         else return;
  55
  56         if (p->content) {
  57                 elm_notify_content_set(obj, p->content);
  58         }
  59         if(p->repeat_events_exists)
  60                 elm_notify_repeat_events_set(obj, p->repeat_events);
  61         if(p->timeout_exists)
  62                 elm_notify_timeout_set(obj, p->timeout);
  63         if(p->timer_init)
  64                 elm_notify_timer_init(obj);
  65
  66         if (p->orient)
  67         {
  68                 Elm_Notify_Orient set = _orient_get(p->orient);
  69                 if (set == ELM_NOTIFY_ORIENT_LAST) return;
  70                 elm_notify_orient_set(obj, set);
  71         }
  72 }
  73
  74 static Eina_Bool external_notify_param_set(void *data __UNUSED__,
  75                 Evas_Object *obj, const Edje_External_Param *param)
  76 {
  77         if (!strcmp(param->name, "content")
  78                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
  79         {
  80                 Evas_Object *content = external_common_param_edje_object_get(obj, param);
  81                 if ((strcmp(param->s, "")) && (!content))
  82                         return EINA_FALSE;
  83                 elm_notify_content_set(obj, content);
  84                 return EINA_TRUE;
  85         }
  86         else if (!strcmp(param->name, "repeat_events")
  87                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
  88         {
  89                 elm_notify_repeat_events_set(obj, param->i);
  90                 return EINA_TRUE;
  91         }
  92         else if (!strcmp(param->name, "timer_init")
  93                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
  94         {
  95                 elm_notify_timer_init(obj);
  96                 return EINA_TRUE;
  97         }
  98         else if (!strcmp(param->name, "timeout")
  99                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
 100         {
 101                 elm_notify_timeout_set(obj, param->i);
 102                 return EINA_TRUE;
 103         }
 104         else if (!strcmp(param->name, "orient")
 105                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_CHOICE)
 106         {
 107                 Elm_Notify_Orient set = _orient_get(param->s);
 108                 if (set == ELM_NOTIFY_ORIENT_LAST) return;
 109                 elm_notify_orient_set(obj, set);
 110                 return EINA_TRUE;
 111         }
 112
 113         ERR("unknown parameter '%s' of type '%s'",
 114                         param->name, edje_external_param_type_str(param->type));
 115
 116         return EINA_FALSE;
 117 }
 118
 119 static Eina_Bool external_notify_param_get(void *data __UNUSED__,
 120                 const Evas_Object *obj, Edje_External_Param *param)
 121 {
 122         if (!strcmp(param->name, "content"))
 123         {
 124                 /* not easy to get content name back from live object */
 125                 return EINA_FALSE;
 126         }
 127         else if (!strcmp(param->name, "repeat_events")
 128                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 129         {
 130                 param->i = elm_notify_repeat_events_get(obj);
 131                 return EINA_TRUE;
 132         }
 133         else if (!strcmp(param->name, "timeout")
 134                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
 135         {
 136                 param->i = elm_notify_timeout_get(obj);
 137                 return EINA_TRUE;
 138         }
 139         else if (!strcmp(param->name, "orient")
 140                         && param->type == EDJE_EXTERNAL_PARAM_TYPE_CHOICE)
 141         {
 142                 Elm_Notify_Orient set = elm_notify_orient_get(obj);
 143                 if (set == ELM_NOTIFY_ORIENT_LAST) return EINA_FALSE;
 144                 param->s = orients[set];
 145                 return EINA_TRUE;
 146         }
 147
 148         ERR("unknown parameter '%s' of type '%s'",
 149                         param->name, edje_external_param_type_str(param->type));
 150
 151         return EINA_FALSE;
 152 }
 153
 154 static void * external_notify_params_parse(void *data, Evas_Object *obj,
 155                 const Eina_List *params) {
 156         Elm_Params_Notify *mem;
 157         Edje_External_Param *param;
 158         const Eina_List *l;
 159
 160         mem = external_common_params_parse(Elm_Params_Notify, data, obj, params);
 161         if (!mem)
 162                 return NULL;
 163
 164         EINA_LIST_FOREACH(params, l, param)
 165         {
 166                 if (!strcmp(param->name, "content"))
 167                         mem->content = external_common_param_edje_object_get(obj, param);
 168                 else if (!strcmp(param->name, "timeout"))
 169                 {
 170                         mem->timeout = param->i;
 171                         mem->timeout_exists = EINA_TRUE;
 172                 }
 173                 else if (!strcmp(param->name, "timer_init") && param->i > 0)
 174                 {
 175                         mem->timer_init = EINA_TRUE;
 176                 }
 177                 else if (!strcmp(param->name, "repeat_events"))
 178                 {
 179                         mem->repeat_events = param->i;
 180                         mem->repeat_events_exists = EINA_TRUE;
 181                 }
 182                 else if (!strcmp(param->name, "orient"))
 183                           mem->orient = eina_stringshare_add(param->s);
 184         }
 185
 186         return mem;
 187 }
 188
 189 static Evas_Object *external_notify_content_get(void *data __UNUSED__,
 190                 const Evas_Object *obj, const char *content)
 191 {
 192         if (!strcmp(content, "content"))
 193                 return elm_notify_content_get(obj);
 194
 195         ERR("unknown content '%s'", content);
 196         return NULL;
 197 }
 198
 199 static void external_notify_params_free(void *params) {
 200         Elm_Params_Notify *mem = params;
 201
 202         external_common_params_free(params);
 203 }
 204
 205 static Edje_External_Param_Info external_notify_params[] = {
 206                 DEFINE_EXTERNAL_COMMON_PARAMS,
 207                 EDJE_EXTERNAL_PARAM_INFO_STRING("content"),
 208                 EDJE_EXTERNAL_PARAM_INFO_BOOL("repeat_events"),
 209                 EDJE_EXTERNAL_PARAM_INFO_INT("timeout"),
 210                 EDJE_EXTERNAL_PARAM_INFO_BOOL("timer_init"),
 211                 EDJE_EXTERNAL_PARAM_INFO_SENTINEL
 212 };
 213
 214 DEFINE_EXTERNAL_ICON_ADD(notify, "notify");
 215 DEFINE_EXTERNAL_TYPE_SIMPLE(notify, "Notify")
 216 ;