efl

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[] =
30
{
31
   "none", "hide", "scroll", "menu", NULL
32
};
33

34
static Elm_Toolbar_Shrink_Mode
35
_toolbar_shrink_choices_setting_get(const char *shrink_mode_str)
36
{
37
   assert(sizeof(_toolbar_shrink_modes) /
38
          sizeof(_toolbar_shrink_modes[0]) == ELM_TOOLBAR_SHRINK_LAST + 1);
39
   SHRINK_GET(_toolbar_shrink_modes, shrink_mode_str);
40
   return ELM_TOOLBAR_SHRINK_LAST;
41
}
42

43
static void
44
external_toolbar_state_set(void *data EINA_UNUSED, Evas_Object *obj,
45
                           const void *from_params, const void *to_params,
46
                           float pos EINA_UNUSED)
47
{
48
   const Elm_Params_Toolbar *p;
49
   Elm_Toolbar_Shrink_Mode shrink_mode;
50

51
   if (to_params) p = to_params;
52
   else if (from_params) p = from_params;
53
   else return;
54

55
   if (p->icon_size_exists)
56
     elm_toolbar_icon_size_set(obj, p->icon_size);
57
   if (p->align_exists)
58
     elm_toolbar_align_set(obj, p->align);
59
   if (p->no_select_exists)
60
     {
61
        if (p->no_select)
62
          elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_NONE);
63
        else
64
          elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
65
     }
66
   if (p->always_select_exists)
67
     {
68
        if (p->always_select)
69
          elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_ALWAYS);
70
        else
71
          elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
72
     }
73
   if (p->horizontal_exists)
74
     elm_toolbar_horizontal_set(obj, p->horizontal);
75
   if (p->homogeneous_exists)
76
     elm_toolbar_homogeneous_set(obj, p->homogeneous);
77
   if (p->shrink_mode)
78
     {
79
        shrink_mode = _toolbar_shrink_choices_setting_get(p->shrink_mode);
80
        elm_toolbar_shrink_mode_set(obj, shrink_mode);
81
     }
82
}
83

84
static Eina_Bool
85
external_toolbar_param_set(void *data EINA_UNUSED, Evas_Object *obj,
86
                           const Edje_External_Param *param)
87
{
88
   Elm_Toolbar_Shrink_Mode shrink_mode;
89

90
   if (!strcmp(param->name, "icon size"))
91
     {
92
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
93
          {
94
             elm_toolbar_icon_size_set(obj, param->i);
95
             return EINA_TRUE;
96
          }
97
     }
98
   else if (!strcmp(param->name, "align"))
99
     {
100
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
101
          {
102
             elm_toolbar_align_set(obj, param->d);
103
             return EINA_TRUE;
104
          }
105
     }
106
   else if (!strcmp(param->name, "always select"))
107
     {
108
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
109
          {
110
             if (param->i)
111
               elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_ALWAYS);
112
             else
113
               elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
114
             return EINA_TRUE;
115
          }
116
     }
117
   else if (!strcmp(param->name, "no select"))
118
     {
119
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
120
          {
121
             if (param->i)
122
               elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_NONE);
123
             else
124
               elm_toolbar_select_mode_set (obj, ELM_OBJECT_SELECT_MODE_DEFAULT);
125
             return EINA_TRUE;
126
          }
127
     }
128
   else if (!strcmp(param->name, "horizontal"))
129
     {
130
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
131
          {
132
             elm_toolbar_horizontal_set(obj, param->i);
133
             return EINA_TRUE;
134
          }
135
     }
136
   else if (!strcmp(param->name, "homogeneous"))
137
     {
138
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
139
          {
140
             elm_toolbar_homogeneous_set(obj, param->i);
141
             return EINA_TRUE;
142
          }
143
     }
144
   else if (!strcmp(param->name, "shrink"))
145
     {
146
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
147
          {
148
             shrink_mode = _toolbar_shrink_choices_setting_get(param->s);
149
             elm_toolbar_shrink_mode_set(obj, shrink_mode);
150
             return EINA_TRUE;
151
          }
152
     }
153

154
   ERR("unknown parameter '%s' of type '%s'",
155
       param->name, edje_external_param_type_str(param->type));
156

157
   return EINA_FALSE;
158
}
159

160
static Eina_Bool
161
external_toolbar_param_get(void *data EINA_UNUSED, const Evas_Object *obj,
162
                           Edje_External_Param *param)
163
{
164
   if (!strcmp(param->name, "icon size"))
165
     {
166
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
167
          {
168
             param->i = elm_toolbar_icon_size_get(obj);
169
             return EINA_TRUE;
170
          }
171
     }
172
   else if (!strcmp(param->name, "align"))
173
     {
174
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
175
          {
176
             param->d = elm_toolbar_align_get(obj);
177
             return EINA_TRUE;
178
          }
179
     }
180
   else if (!strcmp(param->name, "always select"))
181
     {
182
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
183
          {
184
             if (elm_toolbar_select_mode_get (obj) ==
185
                 ELM_OBJECT_SELECT_MODE_ALWAYS)
186
               param->d = EINA_TRUE;
187
             else
188
               param->d = EINA_FALSE;
189
             return EINA_TRUE;
190
          }
191
     }
192
   else if (!strcmp(param->name, "no select"))
193
     {
194
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
195
          {
196
             if (elm_toolbar_select_mode_get (obj) ==
197
                 ELM_OBJECT_SELECT_MODE_NONE)
198
               param->i = EINA_TRUE;
199
             else
200
               param->i = EINA_FALSE;
201
             return EINA_TRUE;
202
          }
203
     }
204
   else if (!strcmp(param->name, "horizontal"))
205
     {
206
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
207
          {
208
             param->i = elm_toolbar_horizontal_get(obj);
209
             return EINA_TRUE;
210
          }
211
     }
212
   else if (!strcmp(param->name, "homogeneous"))
213
     {
214
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
215
          {
216
             param->i = elm_toolbar_homogeneous_get(obj);
217
             return EINA_TRUE;
218
          }
219
     }
220
   else if (!strcmp(param->name, "shrink"))
221
     {
222
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
223
          {
224
             Elm_Toolbar_Shrink_Mode shrink_mode;
225
             shrink_mode = elm_toolbar_shrink_mode_get(obj);
226
             param->s = _toolbar_shrink_modes[shrink_mode];
227
             return EINA_TRUE;
228
          }
229
     }
230

231
   ERR("unknown parameter '%s' of type '%s'",
232
       param->name, edje_external_param_type_str(param->type));
233

234
   return EINA_FALSE;
235
}
236

237
static void *
238
external_toolbar_params_parse(void *data EINA_UNUSED,
239
                              Evas_Object *obj EINA_UNUSED,
240
                              const Eina_List *params)
241
{
242
   Elm_Params_Toolbar *mem;
243
   Edje_External_Param *param;
244
   const Eina_List *l;
245

246
   mem = calloc(1, sizeof(Elm_Params_Toolbar));
247
   if (!mem)
248
     return NULL;
249

250
   EINA_LIST_FOREACH(params, l, param)
251
     {
252
        if (!strcmp(param->name, "icon size"))
253
          {
254
             mem->icon_size = param->i;
255
             mem->icon_size_exists = EINA_TRUE;
256
          }
257
        else if (!strcmp(param->name, "align"))
258
          {
259
             mem->align = param->d;
260
             mem->align_exists = EINA_TRUE;
261
          }
262
        else if (!strcmp(param->name, "always select"))
263
          {
264
             mem->always_select = param->i;
265
             mem->always_select_exists = param->i;
266
          }
267
        else if (!strcmp(param->name, "no select"))
268
          {
269
             mem->no_select = param->i;
270
             mem->no_select_exists = EINA_TRUE;
271
          }
272
        else if (!strcmp(param->name, "horizontal"))
273
          {
274
             mem->horizontal = param->i;
275
             mem->horizontal_exists = EINA_TRUE;
276
          }
277
        else if (!strcmp(param->name, "homogeneous"))
278
          {
279
             mem->homogeneous = param->i;
280
             mem->homogeneous_exists = EINA_TRUE;
281
          }
282
        else if (!strcmp(param->name, "shrink"))
283
          mem->shrink_mode = eina_stringshare_add(param->s);
284
     }
285

286
   return mem;
287
}
288

289
static Evas_Object *external_toolbar_content_get(void *data EINA_UNUSED,
290
                                                 const Evas_Object *obj EINA_UNUSED,
291
                                                 const char *content EINA_UNUSED)
292
{
293
   ERR("No content.");
294
   return NULL;
295
}
296

297
static void
298
external_toolbar_params_free(void *params)
299
{
300
   Elm_Params_Toolbar *mem = params;
301
   if (mem->shrink_mode)
302
     eina_stringshare_del(mem->shrink_mode);
303
   free(mem);
304
}
305

306
static Edje_External_Param_Info external_toolbar_params[] = {
307
   DEFINE_EXTERNAL_COMMON_PARAMS,
308
   EDJE_EXTERNAL_PARAM_INFO_STRING("shrink"),
309
   EDJE_EXTERNAL_PARAM_INFO_INT("icon size"),
310
   EDJE_EXTERNAL_PARAM_INFO_DOUBLE("align"),
311
   EDJE_EXTERNAL_PARAM_INFO_BOOL("always select"),
312
   EDJE_EXTERNAL_PARAM_INFO_BOOL("no select"),
313
   EDJE_EXTERNAL_PARAM_INFO_BOOL("horizontal"),
314
   EDJE_EXTERNAL_PARAM_INFO_BOOL("homogeneous"),
315

316
   EDJE_EXTERNAL_PARAM_INFO_SENTINEL
317
};
318

319
DEFINE_EXTERNAL_ICON_ADD(toolbar, "toolbar");
320
DEFINE_EXTERNAL_TYPE_SIMPLE(toolbar, "Toolbar");
321