aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/edje/src/bin/edje_convert.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--libraries/edje/src/bin/edje_convert.c459
1 files changed, 459 insertions, 0 deletions
diff --git a/libraries/edje/src/bin/edje_convert.c b/libraries/edje/src/bin/edje_convert.c
new file mode 100644
index 0000000..63d11ba
--- /dev/null
+++ b/libraries/edje/src/bin/edje_convert.c
@@ -0,0 +1,459 @@
1#include "edje_private.h"
2
3#include "edje_cc.h"
4#include "edje_convert.h"
5
6static const Edje_File *_current_edje_file = NULL;
7
8const Edje_File *
9_edje_file_get(void)
10{
11 return _current_edje_file;
12}
13
14void
15_edje_file_set(const Edje_File *edf)
16{
17 _current_edje_file = edf;
18}
19
20static Eina_Bool
21_edje_file_convert_external(Edje_File *edf, Old_Edje_File *oedf)
22{
23 Edje_External_Directory_Entry *ede;
24 unsigned int max;
25 unsigned int i = 0;
26
27 edf->external_dir = calloc(1, sizeof (Edje_External_Directory));
28 if (!edf->external_dir) return EINA_FALSE;
29 if (!oedf->external_dir) return EINA_TRUE;
30
31 max = eina_list_count(oedf->external_dir->entries);
32 edf->external_dir->entries = calloc(1, sizeof (Edje_External_Directory_Entry) * max);
33 edf->external_dir->entries_count = max;
34
35 if (!edf->external_dir->entries && max)
36 return EINA_FALSE;
37
38 EINA_LIST_FREE(oedf->external_dir->entries, ede)
39 {
40 edf->external_dir->entries[i++].entry = ede->entry;
41 free(ede);
42 }
43
44 free(oedf->external_dir);
45 oedf->external_dir = NULL;
46
47 return EINA_TRUE;
48}
49
50static Eina_Bool
51_edje_file_convert_images(Edje_File *edf, Old_Edje_File *oedf)
52{
53 Edje_Image_Directory_Entry *de;
54 Edje_Image_Directory_Set *ds;
55 Eina_List *l;
56 int max;
57
58 edf->image_dir = calloc(1, sizeof (Edje_Image_Directory));
59 if (!edf->image_dir) return EINA_FALSE;
60 if (!oedf->image_dir) return EINA_TRUE;
61
62 max = -1;
63 EINA_LIST_FOREACH(oedf->image_dir->entries, l, de)
64 if (max < de->id)
65 max = de->id;
66
67 edf->image_dir->entries = calloc(1, sizeof (Edje_Image_Directory_Entry) * (max + 1));
68 edf->image_dir->entries_count = max + 1;
69
70 if (!edf->image_dir->entries && edf->image_dir->entries_count)
71 return EINA_FALSE;
72
73 EINA_LIST_FREE(oedf->image_dir->entries, de)
74 {
75 memcpy(edf->image_dir->entries + de->id,
76 de,
77 sizeof (Edje_Image_Directory_Entry));
78 free(de);
79 }
80
81 max = -1;
82 EINA_LIST_FOREACH(oedf->image_dir->sets, l, ds)
83 if (max < ds->id)
84 max = ds->id;
85
86 edf->image_dir->sets = calloc(1, sizeof (Edje_Image_Directory_Set) * (max + 1));
87 edf->image_dir->sets_count = max + 1;
88
89 if (!edf->image_dir->sets && edf->image_dir->sets_count)
90 {
91 free(edf->image_dir->entries);
92 edf->image_dir->entries = NULL;
93 return EINA_FALSE;
94 }
95
96 EINA_LIST_FREE(oedf->image_dir->sets, ds)
97 {
98 memcpy(edf->image_dir->sets + ds->id,
99 ds,
100 sizeof (Edje_Image_Directory_Set));
101 free(ds);
102 }
103
104 return EINA_TRUE;
105}
106
107Edje_File *
108_edje_file_convert(Eet_File *ef, Old_Edje_File *oedf)
109{
110 Edje_Part_Collection_Directory_Entry *ce;
111 Edje_Font_Directory_Entry *fnt;
112 Edje_File *edf;
113 Eina_List *l;
114 Old_Edje_Data *ed;
115
116 if (oedf->version < 2) return NULL;
117
118 edf = calloc(1, sizeof (Edje_File));
119 if (!edf) return NULL;
120
121 edf->free_strings = 0;
122
123 edf->fonts = eina_hash_string_small_new(free);
124 edf->collection = eina_hash_string_small_new(free);
125 edf->data = eina_hash_string_small_new(free);
126
127 if (!edf->fonts || !edf->collection || !edf->data)
128 goto on_error;
129
130 EINA_LIST_FREE(oedf->data, ed)
131 {
132 Edje_String *es;
133
134 es = calloc(1, sizeof (Edje_String));
135 if (!es) continue;
136
137 es->str = ed->value;
138
139 eina_hash_direct_add(edf->data, ed->key, es);
140 free(ed);
141 }
142
143 EINA_LIST_FOREACH(oedf->collection_dir->entries, l, ce)
144 if (ce->entry)
145 eina_hash_direct_add(edf->collection, ce->entry, ce);
146 else
147 error_and_abort(ef, "Collection %i: name missing.\n", ce->id);
148
149 if (oedf->font_dir)
150 EINA_LIST_FOREACH(oedf->font_dir->entries, l, fnt)
151 eina_hash_direct_add(edf->fonts, fnt->entry, fnt);
152
153 if (!_edje_file_convert_images(edf, oedf))
154 goto on_error;
155
156 if (!_edje_file_convert_external(edf, oedf))
157 goto on_error;
158
159 edf->styles = oedf->styles;
160 edf->color_classes = oedf->color_classes;
161 edf->version = EDJE_FILE_VERSION;
162 edf->feature_ver = oedf->feature_ver;
163 edf->compiler = oedf->compiler;
164
165 edf->dangling = EINA_FALSE;
166 edf->warning = EINA_FALSE;
167
168 /* Below you will find all memory structure that could be cleaned when under
169 memory pressure */
170 edf->collection_cache = NULL;
171 edf->collection_patterns = NULL;
172
173 return edf;
174
175 on_error:
176 eina_hash_free(edf->fonts);
177 eina_hash_free(edf->collection);
178 eina_hash_free(edf->data);
179 free(edf->image_dir);
180 free(edf->external_dir);
181 free(edf);
182 return NULL;
183}
184
185static void
186_edje_collection_program_add(Edje_Program ***array,
187 unsigned int *count,
188 Edje_Program *add)
189{
190 Edje_Program **tmp;
191
192 tmp = realloc(*array, sizeof (Edje_Program*) * (*count + 1));
193 if (!tmp) return ;
194
195 tmp[(*count)++] = add;
196 *array = tmp;
197}
198
199Edje_Part_Collection *
200_edje_collection_convert(Eet_File *ef, Edje_Part_Collection_Directory_Entry *ce, Old_Edje_Part_Collection *oedc)
201{
202 Edje_Part_Collection *edc;
203 Old_Edje_Part *part;
204 Edje_Program *pg;
205 Old_Edje_Data *di;
206 Eina_List *l;
207 char *buffer;
208 unsigned int k;
209
210 oedc->part = ce->entry;
211
212 /* Count each type part and their respective state */
213 EINA_LIST_FOREACH(oedc->parts, l, part)
214 {
215 int *count;
216 int dummy = 0;
217
218
219 switch (part->type)
220 {
221#define CSP(Tp, Ce) \
222 case EDJE_PART_TYPE_##Tp : \
223 count = &Ce->count.Tp; \
224 break;
225
226 CSP(RECTANGLE, ce);
227 CSP(TEXT, ce);
228 CSP(IMAGE, ce);
229 CSP(SWALLOW, ce);
230 CSP(TEXTBLOCK, ce);
231 CSP(GROUP, ce);
232 CSP(BOX, ce);
233 CSP(TABLE, ce);
234 CSP(EXTERNAL, ce);
235 default:
236 count = &dummy;
237 break;
238 }
239
240 *count += eina_list_count(part->other_desc) + 1;
241 }
242 ce->count.part = eina_list_count(oedc->parts);
243
244#define CONVERT_EMN(Tp, Sz, Ce) \
245 buffer = alloca(strlen(ce->entry) + strlen(#Tp) + 2); \
246 sprintf(buffer, "%s/%s", ce->entry, #Tp); \
247 Ce->mp.Tp = eina_mempool_add("one_big", buffer, NULL, sizeof (Sz), Ce->count.Tp);
248
249 CONVERT_EMN(RECTANGLE, Edje_Part_Description_Common, ce);
250 CONVERT_EMN(TEXT, Edje_Part_Description_Text, ce);
251 CONVERT_EMN(IMAGE, Edje_Part_Description_Image, ce);
252 CONVERT_EMN(SWALLOW, Edje_Part_Description_Common, ce);
253 CONVERT_EMN(TEXTBLOCK, Edje_Part_Description_Text, ce);
254 CONVERT_EMN(GROUP, Edje_Part_Description_Common, ce);
255 CONVERT_EMN(BOX, Edje_Part_Description_Box, ce);
256 CONVERT_EMN(TABLE, Edje_Part_Description_Table, ce);
257 CONVERT_EMN(EXTERNAL, Edje_Part_Description_External, ce);
258 CONVERT_EMN(part, Edje_Part, ce);
259
260 /* Change structure layout */
261 edc = calloc(1, sizeof (Edje_Part_Collection));
262 if (!edc) error_and_abort(ef, "Not enough memory\n");
263 ce->ref = edc;
264
265 EINA_LIST_FREE(oedc->programs, pg)
266 {
267 if (!pg->signal && !pg->source)
268 _edje_collection_program_add(&edc->programs.nocmp,
269 &edc->programs.nocmp_count,
270 pg);
271 else if (pg->signal && !strpbrk(pg->signal, "*?[\\")
272 && pg->source && !strpbrk(pg->source, "*?[\\"))
273 _edje_collection_program_add(&edc->programs.strcmp,
274 &edc->programs.strcmp_count,
275 pg);
276 else if (pg->signal && edje_program_is_strncmp(pg->signal)
277 && pg->source && edje_program_is_strncmp(pg->source))
278 _edje_collection_program_add(&edc->programs.strncmp,
279 &edc->programs.strncmp_count,
280 pg);
281 else if (pg->signal && edje_program_is_strrncmp(pg->signal)
282 && pg->source && edje_program_is_strrncmp(pg->source))
283 _edje_collection_program_add(&edc->programs.strrncmp,
284 &edc->programs.strrncmp_count,
285 pg);
286 else
287 _edje_collection_program_add(&edc->programs.fnmatch,
288 &edc->programs.fnmatch_count,
289 pg);
290 }
291
292 edc->data = eina_hash_string_small_new(NULL);
293 EINA_LIST_FREE(oedc->data, di)
294 {
295 Edje_String *es;
296
297 es = calloc(1, sizeof (Edje_String));
298 if (!es) continue ;
299
300 es->str = di->value;
301
302 eina_hash_direct_add(edc->data, di->key, es);
303 free(di);
304 }
305
306 edc->parts_count = eina_list_count(oedc->parts);
307 edc->parts = calloc(edc->parts_count, sizeof (Edje_Part *));
308 if (edc->parts_count && !edc->parts)
309 error_and_abort(ef, "Not enough memory\n");
310 k = 0;
311
312 EINA_LIST_FREE(oedc->parts, part)
313 {
314 Old_Edje_Part_Description *oepd;
315 Edje_Pack_Element *elm;
316 Edje_Part *replacement;
317 unsigned int i;
318
319 replacement = eina_mempool_malloc(ce->mp.part, sizeof (Edje_Part));
320 if (!replacement)
321 error_and_abort(ef, "Not enough memory\n");
322
323 replacement->name = part->name;
324 replacement->default_desc = _edje_description_convert(part->type, ce, part->default_desc);
325
326 replacement->other.desc_count = eina_list_count(part->other_desc);
327 replacement->other.desc = calloc(replacement->other.desc_count, sizeof (Edje_Part_Description_Common*));
328
329 i = 0;
330 EINA_LIST_FREE(part->other_desc, oepd)
331 replacement->other.desc[i++] = _edje_description_convert(part->type, ce, oepd);
332
333 replacement->source = part->source;
334 replacement->source2 = part->source2;
335 replacement->source3 = part->source3;
336 replacement->source4 = part->source4;
337 replacement->source5 = part->source5;
338 replacement->source6 = part->source6;
339 replacement->id = part->id;
340 replacement->clip_to_id = part->clip_to_id;
341 replacement->dragable = part->dragable;
342 replacement->items_count = eina_list_count(part->items);
343 replacement->items = calloc(replacement->items_count, sizeof (Edje_Pack_Element*));
344
345 i = 0;
346 EINA_LIST_FREE(part->items, elm)
347 replacement->items[i++] = elm;
348
349 replacement->type = part->type;
350 replacement->effect = part->effect;
351 replacement->mouse_events = part->mouse_events;
352 replacement->repeat_events = part->repeat_events;
353 replacement->ignore_flags = part->ignore_flags;
354 replacement->scale = part->scale;
355 replacement->precise_is_inside = part->precise_is_inside;
356 replacement->use_alternate_font_metrics = part->use_alternate_font_metrics;
357 replacement->pointer_mode = part->pointer_mode;
358 replacement->entry_mode = part->entry_mode;
359 replacement->select_mode = part->select_mode;
360 replacement->multiline = part->multiline;
361 replacement->api = part->api;
362
363 edc->parts[k++] = replacement;
364
365 free(part);
366 }
367
368 edc->id = oedc->id;
369 edc->alias = oedc->alias;
370 edc->prop.min = oedc->prop.min;
371 edc->prop.max = oedc->prop.max;
372 edc->script = oedc->script;
373 edc->part = oedc->part;
374 edc->script_only = oedc->script_only;
375 edc->lua_script_only = oedc->lua_script_only;
376 edc->checked = oedc->checked;
377
378 free(oedc);
379
380 return edc;
381}
382
383Edje_Part_Description_Common*
384_edje_description_convert(int type,
385 Edje_Part_Collection_Directory_Entry *ce,
386 Old_Edje_Part_Description *oed)
387{
388 Edje_Part_Description_Common *result = NULL;
389
390 switch (type)
391 {
392 case EDJE_PART_TYPE_RECTANGLE:
393 result = eina_mempool_malloc(ce->mp.RECTANGLE,
394 sizeof (Edje_Part_Description_Common));
395 break;
396 case EDJE_PART_TYPE_SWALLOW:
397 result = eina_mempool_malloc(ce->mp.SWALLOW,
398 sizeof (Edje_Part_Description_Common));
399 break;
400 case EDJE_PART_TYPE_GROUP:
401 result = eina_mempool_malloc(ce->mp.GROUP,
402 sizeof (Edje_Part_Description_Common));
403 break;
404
405 case EDJE_PART_TYPE_IMAGE:
406 {
407 Edje_Part_Description_Image *img;
408 Edje_Part_Image_Id *id;
409 unsigned int i = 0;
410
411 img = eina_mempool_malloc(ce->mp.IMAGE, sizeof (Edje_Part_Description_Image));
412
413 img->image.tweens_count = eina_list_count(oed->image.tween_list);
414 img->image.tweens = calloc(img->image.tweens_count,
415 sizeof (Edje_Part_Image_Id*));
416 if (img->image.tweens_count > 0 && !img->image.tweens)
417 {
418 eina_mempool_free(ce->mp.IMAGE, img);
419 return NULL;
420 }
421
422 EINA_LIST_FREE(oed->image.tween_list, id)
423 img->image.tweens[i++] = id;
424
425 img->image.id = oed->image.id;
426 img->image.scale_hint = oed->image.scale_hint;
427 img->image.set = oed->image.set;
428
429 img->image.border = oed->image.border;
430 img->image.fill = oed->image.fill;
431
432 result = &img->common;
433 break;
434 }
435
436#define CONVERT_ALLOC_POOL(Short, Type, Name) \
437 case EDJE_PART_TYPE_##Short: \
438 { \
439 Edje_Part_Description_##Type *Name; \
440 \
441 Name = eina_mempool_malloc(ce->mp.Short, sizeof (Edje_Part_Description_##Type)); \
442 Name->Name = oed->Name; \
443 result = &Name->common; \
444 break; \
445 }
446
447 CONVERT_ALLOC_POOL(TEXT, Text, text);
448 CONVERT_ALLOC_POOL(TEXTBLOCK, Text, text);
449 CONVERT_ALLOC_POOL(BOX, Box, box);
450 CONVERT_ALLOC_POOL(TABLE, Table, table);
451 CONVERT_ALLOC_POOL(EXTERNAL, External, external_params);
452 }
453
454 if (result)
455 *result = oed->common;
456
457 free(oed);
458 return result;
459}