src/edje_externals/elm_slider.c

   1 #include "private.h"
   2
   3 typedef struct _Elm_Params_Slider
   4 {
   5    Elm_Params base;
   6    const char *label;
   7    Evas_Object *icon;
   8    const char *indicator, *unit;
   9    double min, max, value;
  10    Eina_Bool min_exists:1;
  11    Eina_Bool max_exists:1;
  12    Eina_Bool value_exists:1;
  13    Eina_Bool inverted:1;
  14    Eina_Bool inverted_exists:1;
  15    Eina_Bool span:1;
  16    Eina_Bool span_exists:1;
  17    Eina_Bool horizontal:1;
  18    Eina_Bool horizontal_exists:1;
  19    Evas_Object *end_icon;
  20    Eina_Bool indicator_show:1;
  21    Eina_Bool indicator_show_exists:1;
  22 } Elm_Params_Slider;
  23
  24 static void
  25 external_slider_state_set(void *data __UNUSED__, Evas_Object *obj, const void *from_params, const void *to_params, float pos __UNUSED__)
  26 {
  27    const Elm_Params_Slider *p;
  28
  29    if (to_params) p = to_params;
  30    else if (from_params) p = from_params;
  31    else return;
  32
  33    if (p->label)
  34      elm_slider_label_set(obj, p->label);
  35    if (p->icon)
  36      elm_slider_icon_set(obj, p->icon);
  37    if (p->span_exists)
  38      elm_slider_span_size_set(obj, p->span);
  39    if ((p->min_exists) && (p->max_exists))
  40      elm_slider_min_max_set(obj, p->min, p->max);
  41    else if ((p->min_exists) || (p->max_exists))
  42      {
  43         double min, max;
  44         elm_slider_min_max_get(obj, &min, &max);
  45         if (p->min_exists)
  46           elm_slider_min_max_set(obj, p->min, max);
  47         else
  48           elm_slider_min_max_set(obj, min, p->max);
  49      }
  50    if (p->value_exists)
  51      elm_slider_value_set(obj, p->value);
  52    if (p->inverted_exists)
  53      elm_slider_inverted_set(obj, p->inverted);
  54    if (p->horizontal_exists)
  55      elm_slider_horizontal_set(obj, p->horizontal);
  56    if (p->indicator)
  57      elm_slider_indicator_format_set(obj, p->indicator);
  58    if (p->unit)
  59      elm_slider_unit_format_set(obj, p->unit);
  60    if (p->end_icon)
  61      elm_slider_icon_set(obj, p->end_icon);
  62    if (p->indicator_show_exists)
  63      elm_slider_horizontal_set(obj, p->indicator_show);
  64 }
  65
  66 static Eina_Bool
  67 external_slider_param_set(void *data __UNUSED__, Evas_Object *obj, const Edje_External_Param *param)
  68 {
  69    if (!strcmp(param->name, "label"))
  70      {
  71         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
  72           {
  73              elm_slider_label_set(obj, param->s);
  74              return EINA_TRUE;
  75           }
  76      }
  77    else if (!strcmp(param->name, "icon"))
  78      {
  79         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
  80           {
  81              Evas_Object *icon = external_common_param_icon_get(obj, param);
  82              if ((strcmp(param->s, "")) && (!icon)) return EINA_FALSE;
  83              elm_slider_icon_set(obj, icon);
  84              return EINA_TRUE;
  85           }
  86      }
  87    else if (!strcmp(param->name, "min"))
  88      {
  89         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
  90           {
  91              double min, max;
  92              elm_slider_min_max_get(obj, &min, &max);
  93              elm_slider_min_max_set(obj, param->d, max);
  94              return EINA_TRUE;
  95           }
  96      }
  97    else if (!strcmp(param->name, "max"))
  98      {
  99         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 100           {
 101              double min, max;
 102              elm_slider_min_max_get(obj, &min, &max);
 103              elm_slider_min_max_set(obj, min, param->d);
 104              return EINA_TRUE;
 105           }
 106      }
 107    else if (!strcmp(param->name, "value"))
 108      {
 109         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 110           {
 111              elm_slider_value_set(obj, param->d);
 112              return EINA_TRUE;
 113           }
 114      }
 115    else if (!strcmp(param->name, "horizontal"))
 116      {
 117         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 118           {
 119              elm_slider_horizontal_set(obj, param->i);
 120              return EINA_TRUE;
 121           }
 122      }
 123    else if (!strcmp(param->name, "inverted"))
 124      {
 125         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 126           {
 127              elm_slider_inverted_set(obj, param->i);
 128              return EINA_TRUE;
 129           }
 130      }
 131    else if (!strcmp(param->name, "span"))
 132      {
 133         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
 134           {
 135              elm_slider_span_size_set(obj, param->i);
 136              return EINA_TRUE;
 137           }
 138      }
 139    else if (!strcmp(param->name, "unit format"))
 140      {
 141         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 142           {
 143              elm_slider_unit_format_set(obj, param->s);
 144              return EINA_TRUE;
 145           }
 146      }
 147    else if (!strcmp(param->name, "indicator format"))
 148      {
 149         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 150           {
 151              elm_slider_indicator_format_set(obj, param->s);
 152              return EINA_TRUE;
 153           }
 154      }
 155    else if (!strcmp(param->name, "end icon"))
 156      {
 157         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 158           {
 159              Evas_Object *end_icon = external_common_param_icon_get(obj, param);
 160              if ((strcmp(param->s, "")) && (!end_icon)) return EINA_FALSE;
 161              elm_slider_icon_set(obj, end_icon);
 162              return EINA_TRUE;
 163           }
 164      }
 165    else if (!strcmp(param->name, "indicator show"))
 166      {
 167         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 168           {
 169              elm_slider_indicator_show_set(obj, param->i);
 170              return EINA_TRUE;
 171           }
 172      }
 173
 174    ERR("unknown parameter '%s' of type '%s'",
 175        param->name, edje_external_param_type_str(param->type));
 176
 177    return EINA_FALSE;
 178 }
 179
 180 static Eina_Bool
 181 external_slider_param_get(void *data __UNUSED__, const Evas_Object *obj, Edje_External_Param *param)
 182 {
 183    if (!strcmp(param->name, "label"))
 184      {
 185         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 186           {
 187              param->s = elm_slider_label_get(obj);
 188              return EINA_TRUE;
 189           }
 190      }
 191    else if (!strcmp(param->name, "icon"))
 192      {
 193         /* not easy to get icon name back from live object */
 194         return EINA_FALSE;
 195      }
 196    else if (!strcmp(param->name, "min"))
 197      {
 198         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 199           {
 200              double min, max;
 201              elm_slider_min_max_get(obj, &min, &max);
 202              param->d = min;
 203              return EINA_TRUE;
 204           }
 205      }
 206    else if (!strcmp(param->name, "max"))
 207      {
 208         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 209           {
 210              double min, max;
 211              elm_slider_min_max_get(obj, &min, &max);
 212              param->d = max;
 213              return EINA_TRUE;
 214           }
 215      }
 216    else if (!strcmp(param->name, "value"))
 217      {
 218         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 219           {
 220              param->d = elm_slider_value_get(obj);
 221              return EINA_TRUE;
 222           }
 223      }
 224    else if (!strcmp(param->name, "horizontal"))
 225      {
 226         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 227           {
 228              param->i = elm_slider_horizontal_get(obj);
 229              return EINA_TRUE;
 230           }
 231      }
 232    else if (!strcmp(param->name, "inverted"))
 233      {
 234         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 235           {
 236              param->i = elm_slider_inverted_get(obj);
 237              return EINA_TRUE;
 238           }
 239      }
 240    else if (!strcmp(param->name, "span"))
 241      {
 242         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
 243           {
 244              param->i = elm_slider_span_size_get(obj);
 245              return EINA_TRUE;
 246           }
 247      }
 248    else if (!strcmp(param->name, "unit format"))
 249      {
 250         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 251           {
 252              param->s = elm_slider_unit_format_get(obj);
 253              return EINA_TRUE;
 254           }
 255      }
 256    else if (!strcmp(param->name, "indicator format"))
 257      {
 258         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 259           {
 260              param->s = elm_slider_indicator_format_get(obj);
 261              return EINA_TRUE;
 262           }
 263      }
 264    else if (!strcmp(param->name, "end icon"))
 265      {
 266              /* not easy to get icon name back from live object */
 267              return EINA_FALSE;
 268      }
 269    else if (!strcmp(param->name, "indicator show"))
 270      {
 271         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 272           {
 273              return EINA_FALSE;
 274           }
 275      }
 276
 277    ERR("unknown parameter '%s' of type '%s'",
 278        param->name, edje_external_param_type_str(param->type));
 279
 280    return EINA_FALSE;
 281 }
 282
 283 static void *
 284 external_slider_params_parse(void *data __UNUSED__, Evas_Object *obj __UNUSED__, const Eina_List *params)
 285 {
 286    Elm_Params_Slider *mem;
 287    Edje_External_Param *param;
 288    const Eina_List *l;
 289
 290    mem = calloc(1, sizeof(Elm_Params_Slider));
 291    if (!mem)
 292      return NULL;
 293
 294    external_common_icon_param_parse(&mem->icon, obj, params);
 295    external_common_icon_param_parse(&mem->end_icon, obj, params);
 296
 297    EINA_LIST_FOREACH(params, l, param)
 298      {
 299         if (!strcmp(param->name, "span"))
 300           {
 301              mem->span = param->i;
 302              mem->span_exists = EINA_TRUE;
 303           }
 304         else if (!strcmp(param->name, "min"))
 305           {
 306              mem->min = param->d;
 307              mem->min_exists = EINA_TRUE;
 308           }
 309         else if (!strcmp(param->name, "max"))
 310           {
 311              mem->max = param->d;
 312              mem->max_exists = EINA_TRUE;
 313           }
 314         else if (!strcmp(param->name, "value"))
 315           {
 316              mem->value = param->d;
 317              mem->value_exists = EINA_TRUE;
 318           }
 319         else if (!strcmp(param->name, "inverted"))
 320           {
 321              mem->inverted = param->i;
 322              mem->inverted_exists = EINA_TRUE;
 323           }
 324         else if (!strcmp(param->name, "horizontal"))
 325           {
 326              mem->horizontal = param->i;
 327              mem->horizontal_exists = EINA_TRUE;
 328           }
 329         else if (!strcmp(param->name, "unit format"))
 330           mem->unit = eina_stringshare_add(param->s);
 331         else if (!strcmp(param->name, "indicator format"))
 332           mem->indicator = eina_stringshare_add(param->s);
 333         else if (!strcmp(param->name, "indicator show"))
 334           {
 335              mem->indicator_show = param->i;
 336              mem->indicator_show_exists = EINA_TRUE;
 337           }
 338         else if (!strcmp(param->name, "label"))
 339           mem->label = eina_stringshare_add(param->s);
 340      }
 341
 342    return mem;
 343 }
 344
 345 static Evas_Object *external_slider_content_get(void *data __UNUSED__,
 346                 const Evas_Object *obj __UNUSED__, const char *content __UNUSED__)
 347 {
 348         ERR("No content.");
 349         return NULL;
 350 }
 351
 352 static void
 353 external_slider_params_free(void *params)
 354 {
 355    Elm_Params_Slider *mem = params;
 356
 357    if (mem->unit)
 358      eina_stringshare_del(mem->unit);
 359    if (mem->indicator)
 360      eina_stringshare_del(mem->indicator);
 361    if (mem->label)
 362      eina_stringshare_del(mem->label);
 363    free(params);
 364 }
 365
 366 static Edje_External_Param_Info external_slider_params[] = {
 367    DEFINE_EXTERNAL_COMMON_PARAMS,
 368    EDJE_EXTERNAL_PARAM_INFO_STRING("label"),
 369    EDJE_EXTERNAL_PARAM_INFO_STRING("icon"),
 370    EDJE_EXTERNAL_PARAM_INFO_DOUBLE("min"),
 371    EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT("max", 10.0),
 372    EDJE_EXTERNAL_PARAM_INFO_DOUBLE("value"),
 373    EDJE_EXTERNAL_PARAM_INFO_BOOL("horizontal"),
 374    EDJE_EXTERNAL_PARAM_INFO_BOOL("inverted"),
 375    EDJE_EXTERNAL_PARAM_INFO_INT("span"),
 376    EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT("unit format", "%1.2f"),
 377    EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT("indicator format", "%1.2f"),
 378    EDJE_EXTERNAL_PARAM_INFO_STRING("end icon"),
 379    EDJE_EXTERNAL_PARAM_INFO_BOOL("indicator show"),
 380    EDJE_EXTERNAL_PARAM_INFO_SENTINEL
 381 };
 382
 383 DEFINE_EXTERNAL_ICON_ADD(slider, "slider")
 384 DEFINE_EXTERNAL_TYPE_SIMPLE(slider, "Slider")