efl

1
#include "private.h"
2

3
typedef struct _Elm_Params_Progressbar
4
{
5
   Elm_Params base;
6
   const char *label;
7
   Evas_Object *icon;
8
   const char *unit;
9
   double value;
10
   Evas_Coord span;
11
   Eina_Bool value_exists:1;
12
   Eina_Bool span_exists:1;
13
   Eina_Bool inverted:1;
14
   Eina_Bool inverted_exists:1;
15
   Eina_Bool horizontal:1;
16
   Eina_Bool horizontal_exists:1;
17
   Eina_Bool pulse:1;
18
   Eina_Bool pulse_exists:1;
19
   Eina_Bool pulsing:1;
20
   Eina_Bool pulsing_exists:1;
21
} Elm_Params_Progressbar;
22

23
static void
24
external_progressbar_state_set(void *data EINA_UNUSED, Evas_Object *obj,
25
                               const void *from_params, const void *to_params,
26
                               float pos EINA_UNUSED)
27
{
28
   const Elm_Params_Progressbar *p;
29

30
   if (to_params) p = to_params;
31
   else if (from_params) p = from_params;
32
   else return;
33

34
   if (p->label)
35
     elm_object_text_set(obj, p->label);
36
   if (p->icon)
37
     elm_object_part_content_set(obj, "icon", p->icon);
38
   if (p->span_exists)
39
     elm_progressbar_span_size_set(obj, p->span);
40
   if (p->value_exists)
41
     elm_progressbar_value_set(obj, p->value);
42
   if (p->inverted_exists)
43
     elm_progressbar_inverted_set(obj, p->inverted);
44
   if (p->horizontal_exists)
45
     elm_progressbar_horizontal_set(obj, p->horizontal);
46
   if (p->unit)
47
     elm_progressbar_unit_format_set(obj, p->unit);
48
   if (p->pulse_exists)
49
     elm_progressbar_pulse_set(obj, p->pulse);
50
   if  (p->pulsing_exists)
51
     elm_progressbar_pulse(obj, p->pulsing);
52
}
53

54
static Eina_Bool
55
external_progressbar_param_set(void *data EINA_UNUSED, Evas_Object *obj,
56
                               const Edje_External_Param *param)
57
{
58
   if (!strcmp(param->name, "label"))
59
     {
60
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
61
          {
62
             elm_object_text_set(obj, param->s);
63
             return EINA_TRUE;
64
          }
65
     }
66
   else if (!strcmp(param->name, "icon"))
67
     {
68
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
69
          {
70
             Evas_Object *icon = external_common_param_icon_get(obj, param);
71
             if ((strcmp(param->s, "")) && (!icon)) return EINA_FALSE;
72
             elm_object_part_content_set(obj, "icon", icon);
73
             return EINA_TRUE;
74
          }
75
     }
76
   else if (!strcmp(param->name, "value"))
77
     {
78
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
79
          {
80
             elm_progressbar_value_set(obj, param->d);
81
             return EINA_TRUE;
82
          }
83
     }
84
   else if (!strcmp(param->name, "horizontal"))
85
     {
86
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
87
          {
88
             elm_progressbar_horizontal_set(obj, param->i);
89
             return EINA_TRUE;
90
          }
91
     }
92
  else if (!strcmp(param->name, "pulse"))
93
     {
94
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
95
          {
96
             elm_progressbar_pulse_set(obj, param->i);
97
             return EINA_TRUE;
98
          }
99
     }
100
   else if (!strcmp(param->name, "pulsing"))
101
     {
102
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
103
          {
104
             elm_progressbar_pulse(obj, param->i);
105
             return EINA_TRUE;
106
          }
107
     }
108
   else if (!strcmp(param->name, "inverted"))
109
     {
110
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
111
          {
112
             elm_progressbar_inverted_set(obj, param->i);
113
             return EINA_TRUE;
114
          }
115
     }
116
   else if (!strcmp(param->name, "span"))
117
     {
118
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
119
          {
120
             elm_progressbar_span_size_set(obj, param->i);
121
             return EINA_TRUE;
122
          }
123
     }
124
   else if (!strcmp(param->name, "unit format"))
125
     {
126
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
127
          {
128
             elm_progressbar_unit_format_set(obj, param->s);
129
             return EINA_TRUE;
130
          }
131
     }
132

133
   ERR("unknown parameter '%s' of type '%s'",
134
       param->name, edje_external_param_type_str(param->type));
135

136
   return EINA_FALSE;
137
}
138

139
static Eina_Bool
140
external_progressbar_param_get(void *data EINA_UNUSED, const Evas_Object *obj,
141
                               Edje_External_Param *param)
142
{
143
   if (!strcmp(param->name, "label"))
144
     {
145
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
146
          {
147
             param->s = elm_object_text_get(obj);
148
             return EINA_TRUE;
149
          }
150
     }
151
   else if (!strcmp(param->name, "icon"))
152
     {
153
        /* not easy to get icon name back from live object */
154
        return EINA_FALSE;
155
     }
156
   else if (!strcmp(param->name, "value"))
157
     {
158
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
159
          {
160
             param->d = elm_progressbar_value_get(obj);
161
             return EINA_TRUE;
162
          }
163
     }
164
   else if (!strcmp(param->name, "horizontal"))
165
     {
166
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
167
          {
168
             param->i = elm_progressbar_horizontal_get(obj);
169
             return EINA_TRUE;
170
          }
171
     }
172
   else if (!strcmp(param->name, "pulse"))
173
     {
174
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
175
          {
176
             param->i = elm_progressbar_pulse_get(obj);
177
             return EINA_TRUE;
178
          }
179
     }
180
   else if (!strcmp(param->name, "pulsing"))
181
     {
182
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
183
          {
184
             param->i = elm_progressbar_is_pulsing_get(obj);
185
             return EINA_TRUE;
186
          }
187
     }
188
   else if (!strcmp(param->name, "inverted"))
189
     {
190
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
191
          {
192
             param->i = elm_progressbar_inverted_get(obj);
193
             return EINA_TRUE;
194
          }
195
     }
196
   else if (!strcmp(param->name, "span"))
197
     {
198
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
199
          {
200
             param->i = elm_progressbar_span_size_get(obj);
201
             return EINA_TRUE;
202
          }
203
     }
204
   else if (!strcmp(param->name, "unit format"))
205
     {
206
        if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
207
          {
208
             param->s = elm_progressbar_unit_format_get(obj);
209
             return EINA_TRUE;
210
          }
211
     }
212

213
   ERR("unknown parameter '%s' of type '%s'",
214
       param->name, edje_external_param_type_str(param->type));
215

216
   return EINA_FALSE;
217
}
218

219
static void *
220
external_progressbar_params_parse(void *data EINA_UNUSED,
221
                                  Evas_Object *obj EINA_UNUSED,
222
                                  const Eina_List *params)
223
{
224
   Elm_Params_Progressbar *mem;
225
   Edje_External_Param *param;
226
   const Eina_List *l;
227

228
   mem = calloc(1, sizeof(Elm_Params_Progressbar));
229
   if (!mem)
230
     return NULL;
231

232
   external_common_icon_param_parse(&mem->icon, obj, params);
233

234
   EINA_LIST_FOREACH(params, l, param)
235
     {
236
        if (!strcmp(param->name, "span"))
237
          {
238
             mem->span = param->i;
239
             mem->span_exists = EINA_TRUE;
240
          }
241
        else if (!strcmp(param->name, "value"))
242
          {
243
             mem->value = param->d;
244
             mem->value_exists = EINA_TRUE;
245
          }
246
        else if (!strcmp(param->name, "inverted"))
247
          {
248
             mem->inverted = !!param->i;
249
             mem->inverted_exists = EINA_TRUE;
250
          }
251
        else if (!strcmp(param->name, "horizontal"))
252
          {
253
             mem->horizontal = !!param->i;
254
             mem->horizontal_exists = EINA_TRUE;
255
          }
256
        else if (!strcmp(param->name, "pulse"))
257
          {
258
             mem->pulse = !!param->i;
259
             mem->pulse_exists = EINA_TRUE;
260
          }
261
        else if (!strcmp(param->name, "pulsing"))
262
          {
263
             mem->pulsing = !!param->i;
264
             mem->pulsing_exists = EINA_TRUE;
265
          }
266
        else if (!strcmp(param->name, "unit format"))
267
          mem->unit = eina_stringshare_add(param->s);
268
        else if (!strcmp(param->name, "label"))
269
          mem->label = eina_stringshare_add(param->s);
270
     }
271

272
   return mem;
273
}
274

275
static Evas_Object *external_progressbar_content_get(void *data EINA_UNUSED,
276
                                                     const Evas_Object *obj EINA_UNUSED,
277
                                                     const char *content EINA_UNUSED)
278
{
279
   ERR("No content.");
280
   return NULL;
281
}
282

283
static void
284
external_progressbar_params_free(void *params)
285
{
286
   Elm_Params_Progressbar *mem = params;
287

288
   if (mem->unit)
289
     eina_stringshare_del(mem->unit);
290
   if (mem->label)
291
     eina_stringshare_del(mem->label);
292
   free(params);
293
}
294

295
static Edje_External_Param_Info external_progressbar_params[] = {
296
     DEFINE_EXTERNAL_COMMON_PARAMS,
297
     EDJE_EXTERNAL_PARAM_INFO_STRING("label"),
298
     EDJE_EXTERNAL_PARAM_INFO_STRING("icon"),
299
     EDJE_EXTERNAL_PARAM_INFO_DOUBLE("value"),
300
     EDJE_EXTERNAL_PARAM_INFO_BOOL("horizontal"),
301
     EDJE_EXTERNAL_PARAM_INFO_BOOL("pulse"),
302
     EDJE_EXTERNAL_PARAM_INFO_BOOL("pulsing"),
303
     EDJE_EXTERNAL_PARAM_INFO_BOOL("inverted"),
304
     EDJE_EXTERNAL_PARAM_INFO_INT("span"),
305
     EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT("unit format", "%1.2f"),
306
     EDJE_EXTERNAL_PARAM_INFO_SENTINEL
307
};
308

309
DEFINE_EXTERNAL_ICON_ADD(progressbar, "progressbar");
310
DEFINE_EXTERNAL_TYPE_SIMPLE(progressbar, "Progressbar");
311