src/edje_externals/elm_spinner.c

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