src/edje_externals/elm_toolbar.c

   1 #include <assert.h>
   2
   3 #include "private.h"
   4
   5 typedef struct _Elm_Params_Toolbar
   6 {
   7    Elm_Params base;
   8    int icon_size;
   9    Eina_Bool icon_size_exists:1;
  10    double align;
  11    const char *shrink_mode;
  12    Eina_Bool align_exists:1;
  13    Eina_Bool always_select:1;
  14    Eina_Bool always_select_exists:1;
  15    Eina_Bool no_select:1;
  16    Eina_Bool no_select_exists:1;
  17    Eina_Bool horizontal:1;
  18    Eina_Bool horizontal_exists:1;
  19    Eina_Bool homogeneous:1;
  20    Eina_Bool homogeneous_exists:1;
  21 } Elm_Params_Toolbar;
  22
  23 #define SHRINK_GET(CHOICES, STR)         \
  24    unsigned int i;                       \
  25    for (i = 0; i < (sizeof(CHOICES) / sizeof(CHOICES[0])); ++i) \
  26      if (!strcmp(STR, CHOICES[i]))       \
  27        return i;
  28
  29 static const char *_toolbar_shrink_modes[] = {"none", "hide",
  30                                               "scroll", "menu", NULL};
  31
  32 static Elm_Toolbar_Shrink_Mode
  33 _toolbar_shrink_choices_setting_get(const char *shrink_mode_str)
  34 {
  35    assert(sizeof(_toolbar_shrink_modes) /
  36           sizeof(_toolbar_shrink_modes[0]) == ELM_TOOLBAR_SHRINK_LAST + 1);
  37    SHRINK_GET(_toolbar_shrink_modes, shrink_mode_str);
  38    return ELM_TOOLBAR_SHRINK_LAST;
  39 }
  40
  41 static void
  42 external_toolbar_state_set(void *data __UNUSED__, Evas_Object *obj, const void *from_params, const void *to_params, float pos __UNUSED__)
  43 {
  44    const Elm_Params_Toolbar *p;
  45    Elm_Toolbar_Shrink_Mode shrink_mode;
  46
  47    if (to_params) p = to_params;
  48    else if (from_params) p = from_params;
  49    else return;
  50
  51    if (p->icon_size_exists)
  52      elm_toolbar_icon_size_set(obj, p->icon_size);
  53    if (p->align_exists)
  54      elm_toolbar_align_set(obj, p->align);
  55 <<<<<<< HEAD
  56    if (p->always_select_exists)
  57      elm_toolbar_always_select_mode_set(obj, p->always_select);
  58    if (p->no_select_exists)
  59      elm_toolbar_no_select_mode_set(obj, p->no_select);
  60 =======
  61    if (p->no_select_exists)
  62      {
  63         if (p->no_select)
  64           elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_NONE);
  65         else
  66           elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
  67      }
  68    if (p->always_select_exists)
  69      {
  70         if (p->always_select)
  71           elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_ALWAYS);
  72         else
  73           elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
  74      }
  75 >>>>>>> remotes/origin/upstream
  76    if (p->horizontal_exists)
  77      elm_toolbar_horizontal_set(obj, p->horizontal);
  78    if (p->homogeneous_exists)
  79      elm_toolbar_homogeneous_set(obj, p->homogeneous);
  80    if (p->shrink_mode)
  81      {
  82         shrink_mode = _toolbar_shrink_choices_setting_get(p->shrink_mode);
  83         elm_toolbar_shrink_mode_set(obj, shrink_mode);
  84      }
  85 }
  86
  87 static Eina_Bool
  88 external_toolbar_param_set(void *data __UNUSED__, Evas_Object *obj, const Edje_External_Param *param)
  89 {
  90    Elm_Toolbar_Shrink_Mode shrink_mode;
  91
  92    if (!strcmp(param->name, "icon size"))
  93      {
  94         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
  95           {
  96              elm_toolbar_icon_size_set(obj, param->i);
  97              return EINA_TRUE;
  98           }
  99      }
 100    else if (!strcmp(param->name, "align"))
 101      {
 102         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 103           {
 104              elm_toolbar_align_set(obj, param->d);
 105              return EINA_TRUE;
 106           }
 107      }
 108    else if (!strcmp(param->name, "always select"))
 109      {
 110         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 111           {
 112 <<<<<<< HEAD
 113              elm_toolbar_always_select_mode_set(obj, param->i);
 114 =======
 115              if (param->i)
 116                elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_ALWAYS);
 117              else
 118                elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
 119 >>>>>>> remotes/origin/upstream
 120              return EINA_TRUE;
 121           }
 122      }
 123    else if (!strcmp(param->name, "no select"))
 124      {
 125         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 126           {
 127 <<<<<<< HEAD
 128              elm_toolbar_no_select_mode_set(obj, param->i);
 129 =======
 130              if (param->i)
 131                elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_NONE);
 132              else
 133                elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
 134 >>>>>>> remotes/origin/upstream
 135              return EINA_TRUE;
 136           }
 137      }
 138    else if (!strcmp(param->name, "horizontal"))
 139      {
 140         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 141           {
 142              elm_toolbar_horizontal_set(obj, param->i);
 143              return EINA_TRUE;
 144           }
 145      }
 146    else if (!strcmp(param->name, "homogeneous"))
 147      {
 148         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 149           {
 150              elm_toolbar_homogeneous_set(obj, param->i);
 151              return EINA_TRUE;
 152           }
 153      }
 154    else if (!strcmp(param->name, "shrink"))
 155      {
 156         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 157           {
 158              shrink_mode = _toolbar_shrink_choices_setting_get(param->s);
 159              elm_toolbar_shrink_mode_set(obj, shrink_mode);
 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 Eina_Bool
 171 external_toolbar_param_get(void *data __UNUSED__, const Evas_Object *obj, Edje_External_Param *param)
 172 {
 173    if (!strcmp(param->name, "icon size"))
 174      {
 175         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
 176           {
 177              param->i = elm_toolbar_icon_size_get(obj);
 178              return EINA_TRUE;
 179           }
 180      }
 181    else if (!strcmp(param->name, "align"))
 182      {
 183         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
 184           {
 185              param->d = elm_toolbar_align_get(obj);
 186              return EINA_TRUE;
 187           }
 188      }
 189    else if (!strcmp(param->name, "always select"))
 190      {
 191         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 192           {
 193 <<<<<<< HEAD
 194              param->d = elm_toolbar_always_select_mode_get(obj);
 195 =======
 196              if (elm_toolbar_select_mode_get (obj) ==
 197                  ELM_OBJECT_SELECT_MODE_ALWAYS)
 198                param->d = EINA_TRUE;
 199              else
 200                param->d = EINA_FALSE;
 201 >>>>>>> remotes/origin/upstream
 202              return EINA_TRUE;
 203           }
 204      }
 205    else if (!strcmp(param->name, "no select"))
 206      {
 207         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 208           {
 209 <<<<<<< HEAD
 210              param->i = elm_toolbar_no_select_mode_get(obj);
 211 =======
 212              if (elm_toolbar_select_mode_get (obj) ==
 213                  ELM_OBJECT_SELECT_MODE_NONE)
 214                param->i = EINA_TRUE;
 215              else
 216                param->i = EINA_FALSE;
 217 >>>>>>> remotes/origin/upstream
 218              return EINA_TRUE;
 219           }
 220      }
 221    else if (!strcmp(param->name, "horizontal"))
 222      {
 223         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 224           {
 225              param->i = elm_toolbar_horizontal_get(obj);
 226              return EINA_TRUE;
 227           }
 228      }
 229    else if (!strcmp(param->name, "homogeneous"))
 230      {
 231         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
 232           {
 233              param->i = elm_toolbar_homogeneous_get(obj);
 234              return EINA_TRUE;
 235           }
 236      }
 237    else if (!strcmp(param->name, "shrink"))
 238      {
 239         if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
 240           {
 241              Elm_Toolbar_Shrink_Mode shrink_mode;
 242              shrink_mode = elm_toolbar_shrink_mode_get(obj);
 243              param->s = _toolbar_shrink_modes[shrink_mode];
 244              return EINA_TRUE;
 245           }
 246      }
 247
 248    ERR("unknown parameter '%s' of type '%s'",
 249        param->name, edje_external_param_type_str(param->type));
 250
 251    return EINA_FALSE;
 252 }
 253
 254 static void *
 255 external_toolbar_params_parse(void *data __UNUSED__, Evas_Object *obj __UNUSED__, const Eina_List *params)
 256 {
 257    Elm_Params_Toolbar *mem;
 258    Edje_External_Param *param;
 259    const Eina_List *l;
 260
 261    mem = calloc(1, sizeof(Elm_Params_Toolbar));
 262    if (!mem)
 263      return NULL;
 264
 265    EINA_LIST_FOREACH(params, l, param)
 266      {
 267         if (!strcmp(param->name, "icon size"))
 268           {
 269              mem->icon_size = param->i;
 270              mem->icon_size_exists = EINA_TRUE;
 271           }
 272         else if (!strcmp(param->name, "align"))
 273           {
 274              mem->align = param->d;
 275              mem->align_exists = EINA_TRUE;
 276           }
 277         else if (!strcmp(param->name, "always select"))
 278           {
 279              mem->always_select = param->i;
 280              mem->always_select_exists = param->i;
 281           }
 282         else if (!strcmp(param->name, "no select"))
 283           {
 284              mem->no_select = param->i;
 285              mem->no_select_exists = EINA_TRUE;
 286           }
 287         else if (!strcmp(param->name, "horizontal"))
 288           {
 289              mem->horizontal = param->i;
 290              mem->horizontal_exists = EINA_TRUE;
 291           }
 292         else if (!strcmp(param->name, "homogeneous"))
 293           {
 294              mem->homogeneous = param->i;
 295              mem->homogeneous_exists = EINA_TRUE;
 296           }
 297         else if (!strcmp(param->name, "shrink"))
 298           mem->shrink_mode = eina_stringshare_add(param->s);
 299      }
 300
 301    return mem;
 302 }
 303
 304 static Evas_Object *external_toolbar_content_get(void *data __UNUSED__,
 305                 const Evas_Object *obj __UNUSED__, const char *content __UNUSED__)
 306 {
 307         ERR("No content.");
 308         return NULL;
 309 }
 310
 311 static void
 312 external_toolbar_params_free(void *params)
 313 {
 314    Elm_Params_Toolbar *mem = params;
 315    if (mem->shrink_mode)
 316      eina_stringshare_del(mem->shrink_mode);
 317    free(mem);
 318 }
 319
 320 static Edje_External_Param_Info external_toolbar_params[] = {
 321    DEFINE_EXTERNAL_COMMON_PARAMS,
 322    EDJE_EXTERNAL_PARAM_INFO_STRING("shrink"),
 323    EDJE_EXTERNAL_PARAM_INFO_INT("icon size"),
 324    EDJE_EXTERNAL_PARAM_INFO_DOUBLE("align"),
 325    EDJE_EXTERNAL_PARAM_INFO_BOOL("always select"),
 326    EDJE_EXTERNAL_PARAM_INFO_BOOL("no select"),
 327    EDJE_EXTERNAL_PARAM_INFO_BOOL("horizontal"),
 328    EDJE_EXTERNAL_PARAM_INFO_BOOL("homogeneous"),
 329
 330    EDJE_EXTERNAL_PARAM_INFO_SENTINEL
 331 };
 332
 333 DEFINE_EXTERNAL_ICON_ADD(toolbar, "toolbar");
 334 DEFINE_EXTERNAL_TYPE_SIMPLE(toolbar, "Toolbar");