src/edje_externals/elm_spinner.c

   1 #include "private.h"
   2
   3 typedef struct _Elm_Params_Spinner
   4 {
   5    Elm_Params base;
   6    const char *label_format;
   7    double min, max, step, value;
   8    Eina_Bool min_exists:1;
   9    Eina_Bool max_exists:1;
  10    Eina_Bool step_exists:1;
  11    Eina_Bool value_exists:1;
  12    Eina_Bool wrap_exists:1;
  13    Eina_Bool wrap:1;
  14 } Elm_Params_Spinner;
  15
  16 static void
  17 external_spinner_state_set(void *data __UNUSED__, Evas_Object *obj, const void *from_params, const void *to_params, float pos __UNUSED__)
  18 {
  19    const Elm_Params_Spinner *p;
  20
  21    if (to_params) p = to_params;
  22    else if (from_params) p = from_params;
  23    else return;
  24
  25    if (p->label_format)
  26      elm_spinner_label_format_set(obj, p->label_format);
  27    if ((p->min_exists) && (p->max_exists))
  28      elm_spinner_min_max_set(obj, p->min, p->max);
  29    else if ((p->min_exists) || (p->max_exists))
  30      {
  31         double min, max;
  32         elm_spinner_min_max_get(obj, &min, &max);
  33         if (p->min_exists)
  34           elm_spinner_min_max_set(obj, p->min, max);
  35         else
  36           elm_spinner_min_max_set(obj, min, p->max);
  37      }
  38    if (p->step_exists)
  39      elm_spinner_step_set(obj, p->step);
  40    if (p->value_exists)
  41      elm_spinner_value_set(obj, p->value);
  42    if (p->wrap_exists)
  43      elm_spinner_wrap_set(obj, p->wrap);
  44 }
  45
  46 static Eina_Bool
  47 external_spinner_param_set(void *data __UNUSED__, Evas_Object *obj, const Edje_External_Param *param)
  48 {
  49    if (!strcmp(param->name, "label format"))
  50      {
  51         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
  52           {
  53              elm_spinner_label_format_set(obj, param->s);
  54              return EINA_TRUE;
  55           }
  56      }
  57    else if (!strcmp(param->name, "min"))
  58      {
  59         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
  60           {
  61              double min, max;
  62              elm_spinner_min_max_get(obj, &min, &max);
  63              elm_spinner_min_max_set(obj, param->d, max);
  64              return EINA_TRUE;
  65           }
  66      }
  67    else if (!strcmp(param->name, "max"))
  68      {
  69         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
  70           {
  71              double min, max;
  72              elm_spinner_min_max_get(obj, &min, &max);
  73              elm_spinner_min_max_set(obj, min, param->d);
  74              return EINA_TRUE;
  75           }
  76      }
  77    else if (!strcmp(param->name, "step"))
  78      {
  79         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
  80           {
  81              elm_spinner_step_set(obj, param->d);
  82              return EINA_TRUE;
  83           }
  84      }
  85    else if (!strcmp(param->name, "value"))
  86      {
  87         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
  88           {
  89              elm_spinner_value_set(obj, param->d);
  90              return EINA_TRUE;
  91           }
  92      }
  93    else if (!strcmp(param->name, "wrap"))
  94      {
  95         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
  96           {
  97              elm_spinner_wrap_set(obj, param->i);
  98              return EINA_TRUE;
  99           }
 100      }
 101
 102    ERR("unknown parameter '%s' of type '%s'",
 103        param->name, edje_external_param_type_str(param->type));
 104
 105    return EINA_FALSE;
 106 }
 107
 108 static Eina_Bool
 109 external_spinner_param_get(void *data __UNUSED__, const Evas_Object *obj, Edje_External_Param *param)
 110 {
 111    if (!strcmp(param->name, "label format"))
 112      {
 113         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 114           {
 115              param->s = elm_spinner_label_format_get(obj);
 116              return EINA_TRUE;
 117           }
 118      }
 119    else if (!strcmp(param->name, "min"))
 120      {
 121         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 122           {
 123              double min, max;
 124              elm_spinner_min_max_get(obj, &min, &max);
 125              param->d = min;
 126              return EINA_TRUE;
 127           }
 128      }
 129    else if (!strcmp(param->name, "max"))
 130      {
 131         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 132           {
 133              double min, max;
 134              elm_spinner_min_max_get(obj, &min, &max);
 135              param->d = max;
 136              return EINA_TRUE;
 137           }
 138      }
 139    else if (!strcmp(param->name, "step"))
 140      {
 141         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 142           {
 143              param->d = elm_spinner_step_get(obj);
 144              return EINA_TRUE;
 145           }
 146      }
 147    else if (!strcmp(param->name, "value"))
 148      {
 149         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 150           {
 151              param->d = elm_spinner_value_get(obj);
 152              return EINA_TRUE;
 153           }
 154      }
 155    else if (!strcmp(param->name, "wrap"))
 156      {
 157         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 158           {
 159              param->i = elm_spinner_value_get(obj);
 160              return EINA_TRUE;
 161           }
 162      }
 163
 164    ERR("unknown parameter '%s' of type '%s'",
 165        param->name, edje_external_param_type_str(param->type));
 166
 167    return EINA_FALSE;
 168 }
 169
 170 static void *
 171 external_spinner_params_parse(void *data __UNUSED__, Evas_Object *obj __UNUSED__, const Eina_List *params)
 172 {
 173    Elm_Params_Spinner *mem;
 174    Edje_External_Param *param;
 175    const Eina_List *l;
 176
 177    mem = calloc(1, sizeof(Elm_Params_Spinner));
 178    if (!mem)
 179      return NULL;
 180
 181    EINA_LIST_FOREACH(params, l, param)
 182      {
 183         if (!strcmp(param->name, "label format"))
 184           mem->label_format = eina_stringshare_add(param->s);
 185         else if (!strcmp(param->name, "min"))
 186           {
 187              mem->min = param->d;
 188              mem->min_exists = EINA_TRUE;
 189           }
 190         else if (!strcmp(param->name, "max"))
 191           {
 192              mem->max = param->d;
 193              mem->max_exists = EINA_TRUE;
 194           }
 195         else if (!strcmp(param->name, "step"))
 196           {
 197              mem->step = param->d;
 198              mem->step_exists = EINA_TRUE;
 199           }
 200         else if (!strcmp(param->name, "value"))
 201           {
 202              mem->value = param->d;
 203              mem->value_exists = EINA_TRUE;
 204           }
 205         else if (!strcmp(param->name, "wrap"))
 206           {
 207              mem->wrap = param->i;
 208              mem->wrap_exists = EINA_TRUE;
 209           }
 210      }
 211
 212    return mem;
 213 }
 214
 215 static Evas_Object *external_spinner_content_get(void *data __UNUSED__,
 216                 const Evas_Object *obj __UNUSED__, const char *content __UNUSED__)
 217 {
 218         ERR("No content.");
 219         return NULL;
 220 }
 221
 222 static void
 223 external_spinner_params_free(void *params)
 224 {
 225    Elm_Params_Spinner *mem = params;
 226
 227    if (mem->label_format)
 228      eina_stringshare_del(mem->label_format);
 229    free(mem);
 230 }
 231
 232 static Edje_External_Param_Info external_spinner_params[] = {
 233    DEFINE_EXTERNAL_COMMON_PARAMS,
 234    EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT("label format", "%1.2f"),
 235    EDJE_EXTERNAL_PARAM_INFO_DOUBLE("min"),
 236    EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT("max", 100.0),
 237    EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT("step", 1.0),
 238    EDJE_EXTERNAL_PARAM_INFO_DOUBLE("value"),
 239    EDJE_EXTERNAL_PARAM_INFO_BOOL("wrap"),
 240    EDJE_EXTERNAL_PARAM_INFO_SENTINEL
 241 };
 242
 243 DEFINE_EXTERNAL_ICON_ADD(spinner, "spinner")
 244 DEFINE_EXTERNAL_TYPE_SIMPLE(spinner, "Spinner")