diff options
Diffstat (limited to 'libraries/edje/src/bin/edje_inspector.c')
-rw-r--r-- | libraries/edje/src/bin/edje_inspector.c | 1639 |
1 files changed, 1639 insertions, 0 deletions
diff --git a/libraries/edje/src/bin/edje_inspector.c b/libraries/edje/src/bin/edje_inspector.c new file mode 100644 index 0000000..ed3baaf --- /dev/null +++ b/libraries/edje/src/bin/edje_inspector.c | |||
@@ -0,0 +1,1639 @@ | |||
1 | #ifdef HAVE_CONFIG_H | ||
2 | # include "config.h" | ||
3 | #endif | ||
4 | |||
5 | #include "Edje.h" | ||
6 | #define EDJE_EDIT_IS_UNSTABLE_AND_I_KNOW_ABOUT_IT 1 | ||
7 | #include "Edje_Edit.h" | ||
8 | |||
9 | #include <Ecore.h> | ||
10 | #include <Ecore_Evas.h> | ||
11 | #include <Ecore_Getopt.h> | ||
12 | #include <locale.h> | ||
13 | #include <fnmatch.h> | ||
14 | #include <unistd.h> | ||
15 | |||
16 | static int _log_dom; | ||
17 | #define DBG(...) EINA_LOG_DOM_DBG(_log_dom, __VA_ARGS__) | ||
18 | #define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) | ||
19 | #define WRN(...) EINA_LOG_DOM_WARN(_log_dom, __VA_ARGS__) | ||
20 | #define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) | ||
21 | #define CRIT(...) EINA_LOG_DOM_CRIT(_log_dom, __VA_ARGS__) | ||
22 | |||
23 | #define INDENT " " | ||
24 | #define INDENT2 INDENT INDENT | ||
25 | #define INDENT3 INDENT2 INDENT | ||
26 | #define INDENT4 INDENT3 INDENT | ||
27 | #define INDENT5 INDENT4 INDENT | ||
28 | #define INDENT6 INDENT5 INDENT | ||
29 | #define INDENT7 INDENT6 INDENT | ||
30 | |||
31 | #define FLOAT_PRECISION 0.0001 | ||
32 | #define FDIFF(a, b) (fabs((a) - (b)) > FLOAT_PRECISION) | ||
33 | |||
34 | #ifdef _WIN32 | ||
35 | # define FMT_UCHAR "%c" | ||
36 | #else | ||
37 | # define FMT_UCHAR "%hhu" | ||
38 | #endif | ||
39 | |||
40 | /* context */ | ||
41 | static Eina_List *groups; | ||
42 | static Ecore_Evas *ee; | ||
43 | |||
44 | /* options */ | ||
45 | static const char *file; | ||
46 | static char *group = NULL; | ||
47 | static char *part = NULL; | ||
48 | static char *program = NULL; | ||
49 | static int detail = 1; | ||
50 | static Eina_Bool api_only = EINA_FALSE; | ||
51 | static Eina_Bool api_fix = EINA_FALSE; | ||
52 | static Eina_Bool machine = EINA_FALSE; | ||
53 | |||
54 | static const char *mode_choices[] = { | ||
55 | "groups", | ||
56 | "parts", | ||
57 | "programs", | ||
58 | "groups-names", | ||
59 | "part-names", | ||
60 | "global-data", | ||
61 | "images", | ||
62 | "fonts", | ||
63 | "externals", | ||
64 | NULL, | ||
65 | }; | ||
66 | |||
67 | static const char *detail_choices[] = { | ||
68 | "none", | ||
69 | "terse", | ||
70 | "all", | ||
71 | NULL | ||
72 | }; | ||
73 | |||
74 | const Ecore_Getopt optdesc = { | ||
75 | "edje_inspector", | ||
76 | "%prog [options] <file.edj>", | ||
77 | PACKAGE_VERSION, | ||
78 | "(C) 2010 - The Enlightenment Project", | ||
79 | "BSD", | ||
80 | "Edje file inspector, let one see groups, parts, programs and other details " | ||
81 | "of a compiled (binary) edje file.\n", | ||
82 | 0, | ||
83 | { | ||
84 | ECORE_GETOPT_CHOICE('m', "mode", "Choose which mode to operate on file.", | ||
85 | mode_choices), | ||
86 | ECORE_GETOPT_CHOICE('d', "detail", "Choose detail level (default=terse)", | ||
87 | detail_choices), | ||
88 | ECORE_GETOPT_STORE_STR('g', "group", "Limit output to group (or glob)."), | ||
89 | ECORE_GETOPT_STORE_STR('p', "part", "Limit output to part (or glob)."), | ||
90 | ECORE_GETOPT_STORE_STR('r', "program", | ||
91 | "Limit output to program (or glob)."), | ||
92 | ECORE_GETOPT_STORE_TRUE('a', "api-only", "Limit to just api parts or " | ||
93 | "programs."), | ||
94 | ECORE_GETOPT_STORE_TRUE('A', "api-fix", "Fix API names to be C compliant."), | ||
95 | ECORE_GETOPT_STORE_TRUE('M', "machine", "Produce machine readable output."), | ||
96 | ECORE_GETOPT_LICENSE('L', "license"), | ||
97 | ECORE_GETOPT_COPYRIGHT('C', "copyright"), | ||
98 | ECORE_GETOPT_VERSION('V', "version"), | ||
99 | ECORE_GETOPT_HELP('h', "help"), | ||
100 | ECORE_GETOPT_SENTINEL | ||
101 | } | ||
102 | }; | ||
103 | |||
104 | static inline Eina_Bool | ||
105 | matches(const char *name, const char *pattern) | ||
106 | { | ||
107 | if (!pattern) return EINA_TRUE; | ||
108 | return fnmatch(pattern, name, 0) == 0; | ||
109 | } | ||
110 | |||
111 | static void | ||
112 | group_begin(const char *name) | ||
113 | { | ||
114 | if (machine) printf("GROUP-BEGIN\nNAME: %s\n", name); | ||
115 | else printf("group { name: '%s';\n", name); | ||
116 | } | ||
117 | |||
118 | static void | ||
119 | group_end(void) | ||
120 | { | ||
121 | if (machine) puts("GROUP-END"); | ||
122 | else puts("}"); | ||
123 | } | ||
124 | |||
125 | static void | ||
126 | group_details(Evas_Object *ed) | ||
127 | { | ||
128 | int w, h; | ||
129 | |||
130 | if (detail < 1) return; | ||
131 | |||
132 | if (machine) puts("GROUP-DETAILS-BEGIN"); | ||
133 | |||
134 | w = edje_edit_group_min_w_get(ed); | ||
135 | h = edje_edit_group_min_h_get(ed); | ||
136 | if (machine) printf("MIN-W: %d\nMIN-H: %d\n", w, h); | ||
137 | else if ((w > 0) || (h > 0)) printf(INDENT "min: %d %d;\n", w, h); | ||
138 | |||
139 | w = edje_edit_group_max_w_get(ed); | ||
140 | h = edje_edit_group_max_h_get(ed); | ||
141 | if (machine) printf("MAX-W: %d\nMAX-H: %d\n", w, h); | ||
142 | else if ((w > 0) || (h > 0)) printf(INDENT "max: %d %d;\n", w, h); | ||
143 | |||
144 | if (detail > 1) | ||
145 | { | ||
146 | Eina_List *dl; | ||
147 | dl = edje_edit_group_data_list_get(ed); | ||
148 | if (dl) | ||
149 | { | ||
150 | Eina_List *l; | ||
151 | const char *k; | ||
152 | if (machine) puts(INDENT "GROUP-DETAILS-DATA-BEGIN"); | ||
153 | else puts(INDENT "data {"); | ||
154 | |||
155 | EINA_LIST_FOREACH(dl, l, k) | ||
156 | { | ||
157 | const char *v = edje_edit_group_data_value_get(ed, k); | ||
158 | if (machine) printf("ITEM: \"%s\" \"%s\"\n", k, v); | ||
159 | else printf(INDENT2 "item: \"%s\" \"%s\";\n", k, v); | ||
160 | } | ||
161 | |||
162 | edje_edit_string_list_free(dl); | ||
163 | |||
164 | if (machine) puts(INDENT "GROUP-DETAILS-DATA-END"); | ||
165 | else puts(INDENT "}"); | ||
166 | } | ||
167 | } | ||
168 | |||
169 | if (machine) puts("GROUP-DETAILS-END"); | ||
170 | } | ||
171 | |||
172 | static void | ||
173 | parts_begin(void) | ||
174 | { | ||
175 | if (machine) puts("PARTS-BEGIN"); | ||
176 | else puts(INDENT "parts {"); | ||
177 | } | ||
178 | |||
179 | static void | ||
180 | parts_end(void) | ||
181 | { | ||
182 | if (machine) puts("PARTS-END"); | ||
183 | else puts(INDENT "}"); | ||
184 | } | ||
185 | |||
186 | static const char * | ||
187 | part_type_name_get(Edje_Part_Type t) | ||
188 | { | ||
189 | switch (t) | ||
190 | { | ||
191 | case EDJE_PART_TYPE_RECTANGLE: | ||
192 | return "RECT"; | ||
193 | case EDJE_PART_TYPE_TEXT: | ||
194 | return "TEXT"; | ||
195 | case EDJE_PART_TYPE_IMAGE: | ||
196 | return "IMAGE"; | ||
197 | case EDJE_PART_TYPE_PROXY: | ||
198 | return "PROXY"; | ||
199 | case EDJE_PART_TYPE_SWALLOW: | ||
200 | return "SWALLOW"; | ||
201 | case EDJE_PART_TYPE_TEXTBLOCK: | ||
202 | return "TEXTBLOCK"; | ||
203 | case EDJE_PART_TYPE_GRADIENT: | ||
204 | return "GRADIENT"; | ||
205 | case EDJE_PART_TYPE_GROUP: | ||
206 | return "GROUP"; | ||
207 | case EDJE_PART_TYPE_BOX: | ||
208 | return "BOX"; | ||
209 | case EDJE_PART_TYPE_TABLE: | ||
210 | return "TABLE"; | ||
211 | case EDJE_PART_TYPE_EXTERNAL: | ||
212 | return "EXTERNAL"; | ||
213 | |||
214 | case EDJE_PART_TYPE_NONE: | ||
215 | case EDJE_PART_TYPE_LAST: | ||
216 | ERR("Invalid part type %d", t); | ||
217 | return "???"; | ||
218 | default: | ||
219 | ERR("Unknown part type %d", t); | ||
220 | return "???"; | ||
221 | } | ||
222 | } | ||
223 | |||
224 | static void | ||
225 | state_begin(const char *state, double value) | ||
226 | { | ||
227 | if (machine) | ||
228 | printf("PART-STATE-BEGIN\nNAME: %s\nVALUE: %2.1f\n", state, value); | ||
229 | else | ||
230 | { | ||
231 | printf(INDENT3 "description { state: \"%s\" %2.1f;", state, value); | ||
232 | if (detail > 0) putchar('\n'); | ||
233 | } | ||
234 | } | ||
235 | |||
236 | static const char * | ||
237 | aspect_pref_name_get(int id) | ||
238 | { | ||
239 | switch (id) | ||
240 | { | ||
241 | case 0: return "NONE"; | ||
242 | case 1: return "VERTICAL"; | ||
243 | case 2: return "HORIZONTAL"; | ||
244 | case 3: return "BOTH"; | ||
245 | default: | ||
246 | ERR("Unknown aspect preference %d", id); | ||
247 | return "???"; | ||
248 | } | ||
249 | } | ||
250 | |||
251 | static const char * | ||
252 | border_fill_name_get(int id) | ||
253 | { | ||
254 | switch (id) | ||
255 | { | ||
256 | case 0: return "NONE"; | ||
257 | case 1: return "DEFAULT"; | ||
258 | case 2: return "SOLID"; | ||
259 | default: | ||
260 | ERR("Unknown border fill %d", id); | ||
261 | return "???"; | ||
262 | } | ||
263 | } | ||
264 | |||
265 | static void | ||
266 | state_details(Evas_Object *ed, const char *part, const char *state, double value) | ||
267 | { | ||
268 | Edje_Part_Type t = edje_edit_part_type_get(ed, part); | ||
269 | double dx, dy; | ||
270 | const char *str, *str2; | ||
271 | int x, y, r, g, b, a; | ||
272 | |||
273 | if (detail < 1) return; | ||
274 | |||
275 | b = edje_edit_state_visible_get(ed, part, state, value); | ||
276 | if (machine) printf("VISIBLE: %d\n", b); | ||
277 | else if (!b) puts(INDENT4 "visible: 0;"); | ||
278 | |||
279 | edje_edit_state_color_get(ed, part, state, value, &r, &g, &b, &a); | ||
280 | if (machine) | ||
281 | printf("COLOR-R: %d\nCOLOR-G: %d\nCOLOR-B: %d\nCOLOR-A: %d\n", r, g, b, a); | ||
282 | else if ((r != 255) || (g != 255) || (b != 255) || (a != 255)) | ||
283 | printf(INDENT4 "color: %d %d %d %d;\n", r, g, b, a); | ||
284 | |||
285 | if (detail > 1) | ||
286 | { | ||
287 | edje_edit_state_color2_get(ed, part, state, value, &r, &g, &b, &a); | ||
288 | if (machine) | ||
289 | printf("COLOR2-R: %d\nCOLOR2-G: %d\nCOLOR2-B: %d\nCOLOR2-A: %d\n", | ||
290 | r, g, b, a); | ||
291 | else if ((r != 255) || (g != 255) || (b != 255) || (a != 255)) | ||
292 | printf(INDENT4 "color2: %d %d %d %d;\n", r, g, b, a); | ||
293 | |||
294 | edje_edit_state_color3_get(ed, part, state, value, &r, &g, &b, &a); | ||
295 | if (machine) | ||
296 | printf("COLOR3-R: %d\nCOLOR3-G: %d\nCOLOR3-B: %d\nCOLOR3-A: %d\n", | ||
297 | r, g, b, a); | ||
298 | else if ((r != 255) || (g != 255) || (b != 255) || (a != 255)) | ||
299 | printf(INDENT4 "color3: %d %d %d %d;\n", r, g, b, a); | ||
300 | } | ||
301 | |||
302 | dx = edje_edit_state_align_x_get(ed, part, state, value); | ||
303 | dy = edje_edit_state_align_y_get(ed, part, state, value); | ||
304 | if (machine) printf("ALIGN-X: %g\nALIGN-Y: %g\n", dx, dy); | ||
305 | else if (FDIFF(dx, 0.5) || FDIFF(dy, 0.5)) | ||
306 | printf(INDENT4 "align: %g %g;\n", dx, dy); | ||
307 | |||
308 | x = edje_edit_state_min_w_get(ed, part, state, value); | ||
309 | y = edje_edit_state_min_h_get(ed, part, state, value); | ||
310 | if (machine) printf("MIN-W: %d\nMIN-H: %d\n", x, y); | ||
311 | else if ((x) || (y)) printf(INDENT4 "min: %d %d;\n", x, y); | ||
312 | |||
313 | x = edje_edit_state_max_w_get(ed, part, state, value); | ||
314 | y = edje_edit_state_max_h_get(ed, part, state, value); | ||
315 | if (machine) printf("MAX-W: %d\nMAX-H: %d\n", x, y); | ||
316 | else if ((x != -1) || (y != -1)) printf(INDENT4 "max: %d %d;\n", x, y); | ||
317 | |||
318 | //TODO Support fixed | ||
319 | //TODO Support step | ||
320 | |||
321 | if (detail > 1) | ||
322 | { | ||
323 | dx = edje_edit_state_aspect_min_get(ed, part, state, value); | ||
324 | dy = edje_edit_state_aspect_max_get(ed, part, state, value); | ||
325 | if (machine) printf("ASPECT-MIN: %g\nASPECT-MAX: %g\n", dx, dy); | ||
326 | else if (FDIFF(dx, 0.0) || FDIFF(dy, 0.0)) | ||
327 | printf(INDENT4 "aspect: %g %g;\n", dx, dy); | ||
328 | |||
329 | x = edje_edit_state_aspect_pref_get(ed, part, state, value); | ||
330 | str = aspect_pref_name_get(x); | ||
331 | if (machine) printf("ASPECT-PREFERENCE: %s\n", str); | ||
332 | else if (x) printf(INDENT4 "aspect_preference: %s;\n", str); | ||
333 | /* do not free this str! */ | ||
334 | |||
335 | str = edje_edit_state_color_class_get(ed, part, state, value); | ||
336 | if (machine) printf("COLOR_CLASS: %s\n", str ? str : ""); | ||
337 | else if (str) printf(INDENT4 "color_class: \"%s\";\n", str); | ||
338 | edje_edit_string_free(str); | ||
339 | } | ||
340 | |||
341 | dx = edje_edit_state_rel1_relative_x_get(ed, part, state, value); | ||
342 | dy = edje_edit_state_rel1_relative_y_get(ed, part, state, value); | ||
343 | x = edje_edit_state_rel1_offset_x_get(ed, part, state, value); | ||
344 | y = edje_edit_state_rel1_offset_y_get(ed, part, state, value); | ||
345 | str = edje_edit_state_rel1_to_x_get(ed, part, state, value); | ||
346 | str2 = edje_edit_state_rel1_to_y_get(ed, part, state, value); | ||
347 | if (FDIFF(dx, 0.0) || FDIFF(dy, 0.0) || (x) || (y) || (str) || (str2)) | ||
348 | { | ||
349 | if (machine) puts("REL1-BEGIN"); | ||
350 | else puts(INDENT4 "rel1 {"); | ||
351 | |||
352 | if (machine) printf("RELATIVE-X: %g\nRELATIVE-Y: %g\n", dx, dy); | ||
353 | else if (FDIFF(dx, 0.0) || FDIFF(dy, 0.0)) | ||
354 | printf(INDENT5 "relative: %g %g;\n", dx, dy); | ||
355 | |||
356 | if (machine) printf("OFFSET-X: %d\nOFFSET-Y: %d\n", x, y); | ||
357 | else if ((x) || (y)) printf(INDENT5 "offset: %d %d;\n", x, y); | ||
358 | |||
359 | if (machine) | ||
360 | printf("TO-X: %s\nTO-Y: %s\n", str ? str : "", str2 ? str2 : ""); | ||
361 | else if (((str) && (str2)) && (!strcmp(str, str2))) | ||
362 | printf(INDENT5 "to: \"%s\";\n", str); | ||
363 | else | ||
364 | { | ||
365 | if (str) printf(INDENT5 "to_x: \"%s\";\n", str); | ||
366 | if (str2) printf(INDENT5 "to_y: \"%s\";\n", str2); | ||
367 | } | ||
368 | |||
369 | if (machine) puts("REL1-END"); | ||
370 | else puts(INDENT4 "}"); | ||
371 | } | ||
372 | edje_edit_string_free(str); | ||
373 | edje_edit_string_free(str2); | ||
374 | |||
375 | dx = edje_edit_state_rel2_relative_x_get(ed, part, state, value); | ||
376 | dy = edje_edit_state_rel2_relative_y_get(ed, part, state, value); | ||
377 | x = edje_edit_state_rel2_offset_x_get(ed, part, state, value); | ||
378 | y = edje_edit_state_rel2_offset_y_get(ed, part, state, value); | ||
379 | str = edje_edit_state_rel2_to_x_get(ed, part, state, value); | ||
380 | str2 = edje_edit_state_rel2_to_y_get(ed, part, state, value); | ||
381 | if (FDIFF(dx, 1.0) || FDIFF(dy, 1.0) || (x != -1) || (y != -1) || | ||
382 | (str) || (str2)) | ||
383 | { | ||
384 | if (machine) puts("REL2-BEGIN"); | ||
385 | else puts(INDENT4 "rel2 {"); | ||
386 | |||
387 | if (machine) printf("RELATIVE-X: %g\nRELATIVE-Y: %g\n", dx, dy); | ||
388 | else if (FDIFF(dx, 1.0) || FDIFF(dy, 1.0)) | ||
389 | printf(INDENT5 "relative: %g %g;\n", dx, dy); | ||
390 | |||
391 | if (machine) printf("OFFSET-X: %d\nOFFSET-Y: %d\n", x, y); | ||
392 | else if ((x != -1) || (y != -1)) | ||
393 | printf(INDENT5 "offset: %d %d;\n", x, y); | ||
394 | |||
395 | if (machine) | ||
396 | printf("TO-X: %s\nTO-Y: %s\n", str ? str : "", str2 ? str2 : ""); | ||
397 | else if (((str) && (str2)) && (!strcmp(str, str2))) | ||
398 | printf(INDENT5 "to: \"%s\";\n", str); | ||
399 | else | ||
400 | { | ||
401 | if (str) printf(INDENT5 "to_x: \"%s\";\n", str); | ||
402 | if (str2) printf(INDENT5 "to_y: \"%s\";\n", str2); | ||
403 | } | ||
404 | |||
405 | if (machine) puts("REL2-END"); | ||
406 | else puts(INDENT4 "}"); | ||
407 | } | ||
408 | edje_edit_string_free(str); | ||
409 | edje_edit_string_free(str2); | ||
410 | |||
411 | if (t == EDJE_PART_TYPE_IMAGE) | ||
412 | { | ||
413 | str = edje_edit_state_image_get(ed, part, state, value); | ||
414 | |||
415 | if (machine) printf("IMAGE-BEGIN\nNORMAL: %s\n", str ? str : ""); | ||
416 | else if (detail > 1) | ||
417 | { | ||
418 | puts(INDENT4 "image {"); | ||
419 | if (str) printf(INDENT5 "normal: \"%s\";\n", str); | ||
420 | } | ||
421 | else if (str) printf(INDENT4 "image.normal: \"%s\";\n", str); | ||
422 | |||
423 | edje_edit_string_free(str); | ||
424 | |||
425 | if (detail > 1) | ||
426 | { | ||
427 | Eina_List *tweens, *l; | ||
428 | int bl, br, bt, bb, x2, y2; | ||
429 | double dx2, dy2; | ||
430 | Eina_Bool has_orgin, has_size; | ||
431 | |||
432 | tweens = edje_edit_state_tweens_list_get(ed, part, state, value); | ||
433 | EINA_LIST_FOREACH(tweens, l, str) | ||
434 | { | ||
435 | if (machine) printf("TWEEN: %s\n", str); | ||
436 | else printf(INDENT5 "tween: \"%s\";\n", str); | ||
437 | } | ||
438 | edje_edit_string_list_free(tweens); | ||
439 | |||
440 | edje_edit_state_image_border_get | ||
441 | (ed, part, state, value, &bl, &br, &bt, &bb); | ||
442 | if (machine) | ||
443 | printf("BORDER-LEFT: %d\nBORDER-RIGHT: %d\n" | ||
444 | "BORDER-TOP: %d\nBORDER-BOTTOM: %d\n", bl, br, bt, bb); | ||
445 | else if ((bl) || (br) || (bt) || (bb)) | ||
446 | printf(INDENT5 "border: %d %d %d %d;\n", bl, br, bt, bb); | ||
447 | |||
448 | x = edje_edit_state_image_border_fill_get(ed, part, state, value); | ||
449 | str = border_fill_name_get(x); | ||
450 | if (machine) printf("BORDER-FILL: %s\n", str); | ||
451 | else if (x != 1) printf(INDENT5 "middle: %s;\n", str); | ||
452 | /* do not free str! */ | ||
453 | |||
454 | // TODO support image.fill.smooth | ||
455 | |||
456 | dx = edje_edit_state_fill_origin_relative_x_get | ||
457 | (ed, part, state, value); | ||
458 | dy = edje_edit_state_fill_origin_relative_y_get | ||
459 | (ed, part, state, value); | ||
460 | x = edje_edit_state_fill_origin_offset_x_get | ||
461 | (ed, part, state, value); | ||
462 | y = edje_edit_state_fill_origin_offset_y_get | ||
463 | (ed, part, state, value); | ||
464 | |||
465 | dx2 = edje_edit_state_fill_size_relative_x_get | ||
466 | (ed, part, state, value); | ||
467 | dy2 = edje_edit_state_fill_size_relative_y_get | ||
468 | (ed, part, state, value); | ||
469 | x2 = edje_edit_state_fill_size_offset_x_get | ||
470 | (ed, part, state, value); | ||
471 | y2 = edje_edit_state_fill_size_offset_y_get | ||
472 | (ed, part, state, value); | ||
473 | |||
474 | has_orgin = (FDIFF(dx, 0.0) || FDIFF(dy, 0.0) || (x) || (y)); | ||
475 | has_size = (FDIFF(dx2, 1.0) || FDIFF(dy2, 1.0) || (x2) || (y2)); | ||
476 | |||
477 | if ((has_orgin) || (has_size)) | ||
478 | { | ||
479 | if (machine) puts("IMAGE-FILL-BEGIN"); | ||
480 | else puts(INDENT5 "fill {"); | ||
481 | |||
482 | if (has_orgin) | ||
483 | { | ||
484 | if (machine) | ||
485 | printf("ORIGIN-RELATIVE-X: %g\n" | ||
486 | "ORIGIN-RELATIVE-Y: %g\n" | ||
487 | "ORIGIN-OFFSET-X: %d\n" | ||
488 | "ORIGIN-OFFSET-Y: %d\n", | ||
489 | dx, dy, x, y); | ||
490 | else | ||
491 | printf(INDENT6 "origin {\n" | ||
492 | INDENT7 "relative: %g %g;\n" | ||
493 | INDENT7 "offset: %d %d;\n" | ||
494 | INDENT6 "}\n", | ||
495 | dx, dy, x, y); | ||
496 | } | ||
497 | |||
498 | if (has_size) | ||
499 | { | ||
500 | if (machine) | ||
501 | printf("SIZE-RELATIVE-X: %g\n" | ||
502 | "SIZE-RELATIVE-Y: %g\n" | ||
503 | "SIZE-OFFSET-X: %d\n" | ||
504 | "SIZE-OFFSET-Y: %d\n", | ||
505 | dx2, dy2, x2, y2); | ||
506 | else | ||
507 | printf(INDENT6 "size {\n" | ||
508 | INDENT7 "relative: %g %g;\n" | ||
509 | INDENT7 "offset: %d %d;\n" | ||
510 | INDENT6 "}\n", | ||
511 | dx2, dy2, x2, y2); | ||
512 | } | ||
513 | |||
514 | if (machine) puts("IMAGE-FILL-END"); | ||
515 | else puts(INDENT5 "}"); | ||
516 | } | ||
517 | } | ||
518 | |||
519 | if (machine) puts("IMAGE-END"); | ||
520 | else if (detail > 1) puts(INDENT4 "}"); | ||
521 | } | ||
522 | else if (t == EDJE_PART_TYPE_PROXY) | ||
523 | { | ||
524 | int x2, y2; | ||
525 | double dx2, dy2; | ||
526 | Eina_Bool has_orgin, has_size; | ||
527 | |||
528 | if (machine) puts("PROXY-BEGIN"); | ||
529 | else puts(INDENT4 "proxy {"); | ||
530 | // TODO Support source | ||
531 | // TODO support proxy.fill.smooth | ||
532 | |||
533 | dx = edje_edit_state_fill_origin_relative_x_get | ||
534 | (ed, part, state, value); | ||
535 | dy = edje_edit_state_fill_origin_relative_y_get | ||
536 | (ed, part, state, value); | ||
537 | x = edje_edit_state_fill_origin_offset_x_get | ||
538 | (ed, part, state, value); | ||
539 | y = edje_edit_state_fill_origin_offset_y_get | ||
540 | (ed, part, state, value); | ||
541 | |||
542 | dx2 = edje_edit_state_fill_size_relative_x_get | ||
543 | (ed, part, state, value); | ||
544 | dy2 = edje_edit_state_fill_size_relative_y_get | ||
545 | (ed, part, state, value); | ||
546 | x2 = edje_edit_state_fill_size_offset_x_get | ||
547 | (ed, part, state, value); | ||
548 | y2 = edje_edit_state_fill_size_offset_y_get | ||
549 | (ed, part, state, value); | ||
550 | |||
551 | has_orgin = (FDIFF(dx, 0.0) || FDIFF(dy, 0.0) || (x) || (y)); | ||
552 | has_size = (FDIFF(dx2, 1.0) || FDIFF(dy2, 1.0) || (x2) || (y2)); | ||
553 | |||
554 | if ((has_orgin) || (has_size)) | ||
555 | { | ||
556 | if (machine) puts("PROXY-FILL-BEGIN"); | ||
557 | else puts(INDENT5 "fill {"); | ||
558 | |||
559 | if (has_orgin) | ||
560 | { | ||
561 | if (machine) | ||
562 | printf("ORIGIN-RELATIVE-X: %g\n" | ||
563 | "ORIGIN-RELATIVE-Y: %g\n" | ||
564 | "ORIGIN-OFFSET-X: %d\n" | ||
565 | "ORIGIN-OFFSET-Y: %d\n", | ||
566 | dx, dy, x, y); | ||
567 | else | ||
568 | printf(INDENT6 "origin {\n" | ||
569 | INDENT7 "relative: %g %g;\n" | ||
570 | INDENT7 "offset: %d %d;\n" | ||
571 | INDENT6 "}\n", | ||
572 | dx, dy, x, y); | ||
573 | } | ||
574 | |||
575 | if (has_size) | ||
576 | { | ||
577 | if (machine) | ||
578 | printf("SIZE-RELATIVE-X: %g\n" | ||
579 | "SIZE-RELATIVE-Y: %g\n" | ||
580 | "SIZE-OFFSET-X: %d\n" | ||
581 | "SIZE-OFFSET-Y: %d\n", | ||
582 | dx2, dy2, x2, y2); | ||
583 | else | ||
584 | printf(INDENT6 "size {\n" | ||
585 | INDENT7 "relative: %g %g;\n" | ||
586 | INDENT7 "offset: %d %d;\n" | ||
587 | INDENT6 "}\n", | ||
588 | dx2, dy2, x2, y2); | ||
589 | } | ||
590 | |||
591 | if (machine) puts("PROXY-FILL-END"); | ||
592 | else puts(INDENT5 "}"); | ||
593 | } | ||
594 | |||
595 | if (machine) puts("PROXY-END"); | ||
596 | else puts(INDENT4 "}"); | ||
597 | } | ||
598 | else if ((t == EDJE_PART_TYPE_TEXTBLOCK) || (t == EDJE_PART_TYPE_TEXT)) | ||
599 | { | ||
600 | if (machine) puts("TEXT-BEGIN"); | ||
601 | else puts(INDENT4 "text {"); | ||
602 | |||
603 | str = edje_edit_state_text_get(ed, part, state, value); | ||
604 | if (machine) printf("TEXT: %s\n", str ? str : ""); | ||
605 | else if (str) printf(INDENT5 "text: \"%s\";\n", str); | ||
606 | edje_edit_string_free(str); | ||
607 | |||
608 | str = edje_edit_state_font_get(ed, part, state, value); | ||
609 | if (machine) printf("FONT: %s\n", str ? str : ""); | ||
610 | else if (str) printf(INDENT5 "font: \"%s\";\n", str); | ||
611 | edje_edit_string_free(str); | ||
612 | |||
613 | x = edje_edit_state_text_size_get(ed, part, state, value); | ||
614 | if (machine) printf("SIZE: %d\n", x); | ||
615 | else if (x > 0) printf(INDENT5 "size: %d;\n", x); | ||
616 | |||
617 | // TODO text_class | ||
618 | |||
619 | dx = edje_edit_state_text_align_x_get(ed, part, state, value); | ||
620 | dy = edje_edit_state_text_align_y_get(ed, part, state, value); | ||
621 | if (machine) printf("TEXT-ALIGN-X: %g\nTEXT-ALIGN-Y: %g\n", dx, dy); | ||
622 | else if (FDIFF(dx, 0.5) || FDIFF(dy, 0.5)) | ||
623 | printf(INDENT5 "align: %g %g;\n", dx, dy); | ||
624 | |||
625 | x = edje_edit_state_text_fit_x_get(ed, part, state, value); | ||
626 | y = edje_edit_state_text_fit_y_get(ed, part, state, value); | ||
627 | if (machine) printf("TEXT-FIT-X: %d\nTEXT-FIT-Y: %d\n", x, y); | ||
628 | else if ((x) || (y)) printf(INDENT5 "fit: %d %d;\n", x, y); | ||
629 | |||
630 | dx = edje_edit_state_text_elipsis_get(ed, part, state, value); | ||
631 | if (machine) printf("TEXT-ELIPSIS: %g\n", dx); | ||
632 | else if (FDIFF(dx, 0.5)) printf(INDENT5 "elipsis: %g;\n", dx); | ||
633 | |||
634 | if (machine) puts("TEXT-END"); | ||
635 | else puts(INDENT4 "}"); | ||
636 | } | ||
637 | else if (t == EDJE_PART_TYPE_EXTERNAL) | ||
638 | { | ||
639 | const Eina_List *params, *l; | ||
640 | const Edje_External_Param *p; | ||
641 | |||
642 | params = edje_edit_state_external_params_list_get | ||
643 | (ed, part, state, value); | ||
644 | |||
645 | if (params) | ||
646 | { | ||
647 | if (machine) puts("PARAMS-BEGIN"); | ||
648 | else puts(INDENT4 "params {"); | ||
649 | |||
650 | EINA_LIST_FOREACH(params, l, p) | ||
651 | switch (p->type) | ||
652 | { | ||
653 | case EDJE_EXTERNAL_PARAM_TYPE_INT: | ||
654 | printf(INDENT5 "int: \"%s\" \"%d\";\n", p->name, p->i); | ||
655 | break; | ||
656 | case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE: | ||
657 | printf(INDENT5 "double: \"%s\" \"%g\";\n", p->name, p->d); | ||
658 | break; | ||
659 | case EDJE_EXTERNAL_PARAM_TYPE_STRING: | ||
660 | if (p->s) | ||
661 | printf(INDENT5 "string: \"%s\" \"%s\";\n", | ||
662 | p->name, p->s); | ||
663 | break; | ||
664 | case EDJE_EXTERNAL_PARAM_TYPE_BOOL: | ||
665 | printf(INDENT5 "bool: \"%s\" \"%d\";\n", p->name, p->i); | ||
666 | break; | ||
667 | case EDJE_EXTERNAL_PARAM_TYPE_CHOICE: | ||
668 | if (p->s) | ||
669 | printf(INDENT5 "choice: \"%s\" \"%s\";\n", | ||
670 | p->name, p->s); | ||
671 | break; | ||
672 | default: | ||
673 | break; | ||
674 | } | ||
675 | |||
676 | if (machine) puts("PARAMS-END"); | ||
677 | else puts(INDENT4 "}"); | ||
678 | } | ||
679 | } | ||
680 | } | ||
681 | |||
682 | static void | ||
683 | state_end(void) | ||
684 | { | ||
685 | if (machine) puts("PART-STATE-END"); | ||
686 | else if (detail > 0) puts(INDENT3 "}"); | ||
687 | else puts(" }"); | ||
688 | } | ||
689 | |||
690 | static void | ||
691 | part_begin(Evas_Object *ed, const char *name) | ||
692 | { | ||
693 | const char *type = part_type_name_get(edje_edit_part_type_get(ed, name)); | ||
694 | if (machine) printf("PART-BEGIN\nNAME: %s\nTYPE: %s\n", name, type); | ||
695 | else | ||
696 | { | ||
697 | printf(INDENT2 "part { name: '%s'; type: %s;", name, type); | ||
698 | if (detail > 0) putchar('\n'); | ||
699 | } | ||
700 | } | ||
701 | |||
702 | static const char * | ||
703 | text_effect_name_get(Edje_Text_Effect effect) | ||
704 | { | ||
705 | switch (effect) | ||
706 | { | ||
707 | case EDJE_TEXT_EFFECT_NONE: | ||
708 | return "NONE"; | ||
709 | case EDJE_TEXT_EFFECT_PLAIN: | ||
710 | return "PLAIN"; | ||
711 | case EDJE_TEXT_EFFECT_OUTLINE: | ||
712 | return "OUTLINE"; | ||
713 | case EDJE_TEXT_EFFECT_SOFT_OUTLINE: | ||
714 | return "SOFT_OUTLINE"; | ||
715 | case EDJE_TEXT_EFFECT_SHADOW: | ||
716 | return "SHADOW"; | ||
717 | case EDJE_TEXT_EFFECT_SOFT_SHADOW: | ||
718 | return "SOFT_SHADOW"; | ||
719 | case EDJE_TEXT_EFFECT_OUTLINE_SHADOW: | ||
720 | return "OUTLINE_SHADOW"; | ||
721 | case EDJE_TEXT_EFFECT_OUTLINE_SOFT_SHADOW: | ||
722 | return "OUTLINE_SOFT_SHADOW"; | ||
723 | case EDJE_TEXT_EFFECT_FAR_SHADOW: | ||
724 | return "FAR_SHADOW"; | ||
725 | case EDJE_TEXT_EFFECT_FAR_SOFT_SHADOW: | ||
726 | return "FAR_SOFT_SHADOW"; | ||
727 | case EDJE_TEXT_EFFECT_GLOW: | ||
728 | return "GLOW"; | ||
729 | |||
730 | case EDJE_TEXT_EFFECT_LAST: | ||
731 | ERR("Invalid part type %d", effect); | ||
732 | return "???"; | ||
733 | default: | ||
734 | ERR("Unknown effect type %d", effect); | ||
735 | return "???"; | ||
736 | } | ||
737 | } | ||
738 | |||
739 | static inline Eina_Bool | ||
740 | _c_id_allowed(char c) | ||
741 | { | ||
742 | if ((c >= '0') && (c <= '9')) return EINA_TRUE; | ||
743 | if ((c >= 'a') && (c <= 'z')) return EINA_TRUE; | ||
744 | if ((c >= 'A') && (c <= 'Z')) return EINA_TRUE; | ||
745 | return EINA_FALSE; | ||
746 | } | ||
747 | |||
748 | static char * | ||
749 | _api_name_fix(const char *orig) | ||
750 | { | ||
751 | char *d, *d_end, buf[256]; | ||
752 | const char *s; | ||
753 | |||
754 | if (!orig) return NULL; | ||
755 | if (!api_fix) return strdup(orig); | ||
756 | |||
757 | s = orig; | ||
758 | d = buf; | ||
759 | d_end = d + sizeof(buf) - 1; | ||
760 | for (; (*s != '\0') && (d < d_end); s++, d++) | ||
761 | if (_c_id_allowed(*s)) *d = *s; | ||
762 | else *d = '_'; | ||
763 | *d = '\0'; | ||
764 | |||
765 | return strdup(buf); | ||
766 | } | ||
767 | |||
768 | static char * | ||
769 | _part_api_name_get(Evas_Object *ed, const char *part) | ||
770 | { | ||
771 | const char *orig = edje_edit_part_api_name_get(ed, part); | ||
772 | char *fix = _api_name_fix(orig); | ||
773 | edje_edit_string_free(orig); | ||
774 | return fix; | ||
775 | } | ||
776 | |||
777 | static void | ||
778 | part_details(Evas_Object *ed, const char *part) | ||
779 | { | ||
780 | Eina_List *states, *l; | ||
781 | Eina_Bool b; | ||
782 | const char *str, *str2; | ||
783 | char *api; | ||
784 | |||
785 | if (detail < 1) return; | ||
786 | |||
787 | if (machine) puts("PART-DETAILS-BEGIN"); | ||
788 | |||
789 | str = api =_part_api_name_get(ed, part); | ||
790 | str2 = edje_edit_part_api_description_get(ed, part); | ||
791 | if (machine) | ||
792 | { | ||
793 | printf("API-NAME: %s\n", str ? str : ""); | ||
794 | printf("API-DESCRIPTION: %s\n", str2 ? str2 : ""); | ||
795 | } | ||
796 | else if ((str) || (str2)) | ||
797 | printf(INDENT3 "api: \"%s\" \"%s\";\n", str ? str : "", str2 ? str2 : ""); | ||
798 | free(api); | ||
799 | edje_edit_string_free(str2); | ||
800 | |||
801 | b = edje_edit_part_mouse_events_get(ed, part); | ||
802 | if (machine) printf("MOUSE_EVENTS: %d\n", b); | ||
803 | else if (!b) puts(INDENT3 "mouse_events: 0;"); | ||
804 | |||
805 | if (detail > 1) | ||
806 | { | ||
807 | b = edje_edit_part_repeat_events_get(ed, part); | ||
808 | if (machine) printf("REPEAT_EVENTS: %d\n", b); | ||
809 | else if (b) puts(INDENT3 "repeat_events: 1;"); | ||
810 | |||
811 | b = edje_edit_part_scale_get(ed, part); | ||
812 | if (machine) printf("SCALE: %d\n", b); | ||
813 | else if (b) puts(INDENT3 "scale: 1;"); | ||
814 | } | ||
815 | |||
816 | str = edje_edit_part_clip_to_get(ed, part); | ||
817 | if (machine) printf("CLIP_TO: %s\n", str ? str : ""); | ||
818 | else if (str) printf(INDENT3 "clip_to: \"%s\";\n", str); | ||
819 | edje_edit_string_free(str); | ||
820 | |||
821 | str = edje_edit_part_source_get(ed, part); | ||
822 | if (machine) printf("SOURCE: %s\n", str ? str : ""); | ||
823 | else if (str) printf(INDENT3 "source: \"%s\";\n", str); | ||
824 | edje_edit_string_free(str); | ||
825 | |||
826 | if (detail > 1) | ||
827 | { | ||
828 | if (edje_edit_part_type_get(ed, part) == EDJE_PART_TYPE_TEXT) | ||
829 | { | ||
830 | str = text_effect_name_get(edje_edit_part_effect_get(ed, part)); | ||
831 | if (machine) printf("EFFECT: %s\n", str ? str : ""); | ||
832 | else if (str) printf(INDENT3 "effect: %s;\n", str); | ||
833 | /* do not free this str! */ | ||
834 | } | ||
835 | |||
836 | if (edje_edit_part_drag_x_get(ed, part) || | ||
837 | edje_edit_part_drag_y_get(ed, part)) | ||
838 | { | ||
839 | int dir, step, count; | ||
840 | |||
841 | if (machine) puts("DRAGABLE-BEGIN"); | ||
842 | else puts(INDENT3 "dragable {"); | ||
843 | |||
844 | dir = edje_edit_part_drag_x_get(ed, part); | ||
845 | step = edje_edit_part_drag_step_x_get(ed, part); | ||
846 | count = edje_edit_part_drag_count_x_get(ed, part); | ||
847 | if (machine) printf("DRAG-X: %d %d %d\n", dir, step, count); | ||
848 | else printf(INDENT4 "x: %d %d %d;\n", dir, step, count); | ||
849 | |||
850 | dir = edje_edit_part_drag_y_get(ed, part); | ||
851 | step = edje_edit_part_drag_step_y_get(ed, part); | ||
852 | count = edje_edit_part_drag_count_y_get(ed, part); | ||
853 | if (machine) printf("DRAG-Y: %d %d %d\n", dir, step, count); | ||
854 | else printf(INDENT4 "y: %d %d %d;\n", dir, step, count); | ||
855 | |||
856 | str = edje_edit_part_drag_confine_get(ed, part); | ||
857 | if (machine) printf("DRAG-CONFINE: %s\n", str ? str : ""); | ||
858 | else if (str) printf(INDENT4 "confine: \"%s\";\n", str); | ||
859 | edje_edit_string_free(str); | ||
860 | |||
861 | str = edje_edit_part_drag_event_get(ed, part); | ||
862 | if (machine) printf("DRAG-EVENTS: %s\n", str ? str : ""); | ||
863 | else if (str) printf(INDENT4 "events: \"%s\";\n", str); | ||
864 | edje_edit_string_free(str); | ||
865 | |||
866 | if (machine) puts("DRAGABLE-END"); | ||
867 | else puts(INDENT3 "}"); | ||
868 | } | ||
869 | } | ||
870 | |||
871 | states = edje_edit_part_states_list_get(ed, part); | ||
872 | EINA_LIST_FOREACH(states, l, str) | ||
873 | { | ||
874 | char state[512], *delim; | ||
875 | double value; | ||
876 | eina_strlcpy(state, str, sizeof(state)); /* bad states_list! :-( */ | ||
877 | delim = strchr(state, ' '); | ||
878 | *delim = '\0'; | ||
879 | delim++; | ||
880 | value = strtod(delim, NULL); | ||
881 | state_begin(state, value); | ||
882 | state_details(ed, part, state, value); | ||
883 | state_end(); | ||
884 | } | ||
885 | edje_edit_string_list_free(states); | ||
886 | |||
887 | if (machine) puts("PART-DETAILS-END"); | ||
888 | } | ||
889 | |||
890 | static void | ||
891 | part_end(void) | ||
892 | { | ||
893 | if (machine) puts("PART-END"); | ||
894 | else if (detail > 0) puts(INDENT2 "}"); | ||
895 | else puts(" }"); | ||
896 | } | ||
897 | |||
898 | static int | ||
899 | _groups_names_list(void) | ||
900 | { | ||
901 | Eina_List *l; | ||
902 | const char *name; | ||
903 | Eina_Bool found = EINA_FALSE; | ||
904 | |||
905 | EINA_LIST_FOREACH(groups, l, name) | ||
906 | { | ||
907 | if (!matches(name, group)) | ||
908 | { | ||
909 | DBG("filter out group '%s': does not match '%s'", name, group); | ||
910 | continue; | ||
911 | } | ||
912 | found = EINA_TRUE; | ||
913 | puts(name); | ||
914 | } | ||
915 | |||
916 | if (!found) WRN("no groups match '%s'", group); | ||
917 | return !found; | ||
918 | } | ||
919 | |||
920 | static int | ||
921 | _parts_names_list(void) | ||
922 | { | ||
923 | Eina_List *gl, *pl, *parts; | ||
924 | const char *gname, *pname; | ||
925 | Eina_Bool found_group = EINA_FALSE, found_part = EINA_FALSE; | ||
926 | |||
927 | EINA_LIST_FOREACH(groups, gl, gname) | ||
928 | { | ||
929 | Evas_Object *ed; | ||
930 | |||
931 | if (!matches(gname, group)) | ||
932 | { | ||
933 | DBG("filter out group '%s': does not match '%s'", gname, group); | ||
934 | continue; | ||
935 | } | ||
936 | |||
937 | ed = edje_edit_object_add(ecore_evas_get(ee)); | ||
938 | if (!edje_object_file_set(ed, file, gname)) | ||
939 | { | ||
940 | Edje_Load_Error err = edje_object_load_error_get(ed); | ||
941 | const char *errmsg = edje_load_error_str(err); | ||
942 | ERR("could not load group '%s' from file '%s': %s", | ||
943 | gname, file, errmsg); | ||
944 | evas_object_del(ed); | ||
945 | continue; | ||
946 | } | ||
947 | |||
948 | found_group = EINA_TRUE; | ||
949 | group_begin(gname); | ||
950 | |||
951 | parts = edje_edit_parts_list_get(ed); | ||
952 | EINA_LIST_FOREACH(parts, pl, pname) | ||
953 | { | ||
954 | if (!matches(pname, part)) | ||
955 | { | ||
956 | DBG("filter out part '%s': does not match '%s'", pname, part); | ||
957 | continue; | ||
958 | } | ||
959 | if (api_only) | ||
960 | { | ||
961 | if (!edje_edit_part_api_name_get(ed, pname)) | ||
962 | { | ||
963 | DBG("filter out part '%s': not API.", pname); | ||
964 | continue; | ||
965 | } | ||
966 | } | ||
967 | if (machine) printf("PART: %s\n", pname); | ||
968 | else printf(INDENT "part: %s\n", pname); | ||
969 | } | ||
970 | edje_edit_string_list_free(parts); | ||
971 | |||
972 | group_end(); | ||
973 | evas_object_del(ed); | ||
974 | } | ||
975 | |||
976 | if (!found_group) WRN("no groups match '%s'", group); | ||
977 | if (!found_part) WRN("no parts match '%s'", part); | ||
978 | return (!found_group) || (!found_part); | ||
979 | } | ||
980 | |||
981 | static Eina_Bool | ||
982 | _group_parts_list(Evas_Object *ed) | ||
983 | { | ||
984 | Eina_Bool found = EINA_FALSE; | ||
985 | Eina_List *parts, *l; | ||
986 | const char *name; | ||
987 | |||
988 | parts_begin(); | ||
989 | |||
990 | parts = edje_edit_parts_list_get(ed); | ||
991 | EINA_LIST_FOREACH(parts, l, name) | ||
992 | { | ||
993 | if (!matches(name, part)) | ||
994 | { | ||
995 | DBG("filter out part '%s': does not match '%s'", name, part); | ||
996 | continue; | ||
997 | } | ||
998 | if (api_only) | ||
999 | { | ||
1000 | if (!edje_edit_part_api_name_get(ed, name)) | ||
1001 | { | ||
1002 | DBG("filter out part '%s': not API.", name); | ||
1003 | continue; | ||
1004 | } | ||
1005 | } | ||
1006 | |||
1007 | found = EINA_TRUE; | ||
1008 | part_begin(ed, name); | ||
1009 | part_details(ed, name); | ||
1010 | part_end(); | ||
1011 | } | ||
1012 | |||
1013 | parts_end(); | ||
1014 | return found; | ||
1015 | } | ||
1016 | |||
1017 | static void | ||
1018 | programs_begin(void) | ||
1019 | { | ||
1020 | if (machine) puts("PROGRAMS-BEGIN"); | ||
1021 | else puts(INDENT "programs {"); | ||
1022 | } | ||
1023 | |||
1024 | static void | ||
1025 | programs_end(void) | ||
1026 | { | ||
1027 | if (machine) puts("PROGRAMS-END"); | ||
1028 | else puts(INDENT "}"); | ||
1029 | } | ||
1030 | |||
1031 | static void | ||
1032 | program_begin(const char *name) | ||
1033 | { | ||
1034 | if (machine) printf("PROGRAM-BEGIN\nNAME: %s\n", name ? name : ""); | ||
1035 | else | ||
1036 | { | ||
1037 | printf(INDENT2 "program { name: '%s';\n", name ? name : ""); | ||
1038 | } | ||
1039 | } | ||
1040 | |||
1041 | static void | ||
1042 | program_end(void) | ||
1043 | { | ||
1044 | if (machine) puts("PROGRAM-END"); | ||
1045 | else puts(INDENT2 "}"); | ||
1046 | } | ||
1047 | |||
1048 | |||
1049 | static char * | ||
1050 | _program_api_name_get(Evas_Object *ed, const char *program) | ||
1051 | { | ||
1052 | const char *orig = edje_edit_program_api_name_get(ed, program); | ||
1053 | char *fix = _api_name_fix(orig); | ||
1054 | edje_edit_string_free(orig); | ||
1055 | return fix; | ||
1056 | } | ||
1057 | |||
1058 | static const char * | ||
1059 | _transition_name_get(Edje_Tween_Mode mode) | ||
1060 | { | ||
1061 | switch (mode) | ||
1062 | { | ||
1063 | case EDJE_TWEEN_MODE_LINEAR: return "LINEAR"; | ||
1064 | case EDJE_TWEEN_MODE_ACCELERATE: return "ACCELERATE"; | ||
1065 | case EDJE_TWEEN_MODE_DECELERATE: return "DECELERATE"; | ||
1066 | case EDJE_TWEEN_MODE_SINUSOIDAL: return "SINUSOIDAL"; | ||
1067 | default: | ||
1068 | ERR("Unknown transition mode %d", mode); | ||
1069 | return "???"; | ||
1070 | } | ||
1071 | } | ||
1072 | |||
1073 | static void | ||
1074 | program_details(Evas_Object *ed, const char *program) | ||
1075 | { | ||
1076 | const char *str, *str2; | ||
1077 | char *api; | ||
1078 | |||
1079 | if (detail < 1) return; | ||
1080 | |||
1081 | if (machine) puts("PROGRAM-DETAILS-BEGIN"); | ||
1082 | |||
1083 | str = api =_program_api_name_get(ed, program); | ||
1084 | str2 = edje_edit_program_api_description_get(ed, program); | ||
1085 | if (machine) | ||
1086 | { | ||
1087 | printf("API-NAME: %s\n", str ? str : ""); | ||
1088 | printf("API-DESCRIPTION: %s\n", str2 ? str2 : ""); | ||
1089 | } | ||
1090 | else if ((str) || (str2)) | ||
1091 | printf(INDENT3 "api: \"%s\" \"%s\";\n", str ? str : "", str2 ? str2 : ""); | ||
1092 | free(api); | ||
1093 | edje_edit_string_free(str2); | ||
1094 | |||
1095 | str = edje_edit_program_signal_get(ed, program); | ||
1096 | if (machine) printf("SIGNAL: %s\n", str ? str : ""); | ||
1097 | else if (str) printf(INDENT3 "signal: \"%s\";\n", str); | ||
1098 | edje_edit_string_free(str); | ||
1099 | |||
1100 | str = edje_edit_program_source_get(ed, program); | ||
1101 | if (machine) printf("SOURCE: %s\n", str ? str : ""); | ||
1102 | else if (str) printf(INDENT3 "source: \"%s\";\n", str); | ||
1103 | edje_edit_string_free(str); | ||
1104 | |||
1105 | if (detail >= 1) | ||
1106 | { | ||
1107 | Eina_List *lst, *l; | ||
1108 | Edje_Action_Type type = edje_edit_program_action_get(ed, program); | ||
1109 | switch (type) | ||
1110 | { | ||
1111 | case EDJE_ACTION_TYPE_ACTION_STOP: | ||
1112 | if (machine) puts("ACTION: ACTION_STOP"); | ||
1113 | else puts(INDENT3 "action: ACTION_STOP;"); | ||
1114 | break; | ||
1115 | case EDJE_ACTION_TYPE_STATE_SET: | ||
1116 | str = edje_edit_program_state_get(ed, program); | ||
1117 | if (machine) | ||
1118 | printf("ACTION: STATE_SET\nACTION-STATE: %s %g\n", | ||
1119 | str, edje_edit_program_value_get(ed, program)); | ||
1120 | else | ||
1121 | printf(INDENT3 "action: STATE_SET \"%s\" %2.1f;\n", | ||
1122 | str, edje_edit_program_value_get(ed, program)); | ||
1123 | edje_edit_string_free(str); | ||
1124 | break; | ||
1125 | case EDJE_ACTION_TYPE_SIGNAL_EMIT: | ||
1126 | str = edje_edit_program_state_get(ed, program); | ||
1127 | str2 = edje_edit_program_state2_get(ed, program); | ||
1128 | if (machine) | ||
1129 | printf("ACTION: SIGNAL_EMIT\nACTION-SIGNAL: %s\n" | ||
1130 | "ACTION-SOURCE: %s\n", | ||
1131 | str ? str : "", str2 ? str2 : ""); | ||
1132 | else if ((str) || (str2)) | ||
1133 | printf(INDENT3 "action: SIGNAL_EMIT \"%s\" \"%s\";\n", | ||
1134 | str ? str : "", str2 ? str2 : ""); | ||
1135 | edje_edit_string_free(str); | ||
1136 | edje_edit_string_free(str2); | ||
1137 | break; | ||
1138 | //TODO Support Drag | ||
1139 | //~ case EDJE_ACTION_TYPE_DRAG_VAL_SET: | ||
1140 | //~ eina_strbuf_append(buf, I4"action: DRAG_VAL_SET TODO;\n"); | ||
1141 | //~ break; | ||
1142 | //~ case EDJE_ACTION_TYPE_DRAG_VAL_STEP: | ||
1143 | //~ eina_strbuf_append(buf, I4"action: DRAG_VAL_STEP TODO;\n"); | ||
1144 | //~ break; | ||
1145 | //~ case EDJE_ACTION_TYPE_DRAG_VAL_PAGE: | ||
1146 | //~ eina_strbuf_append(buf, I4"action: DRAG_VAL_PAGE TODO;\n"); | ||
1147 | //~ break; | ||
1148 | default: | ||
1149 | ERR("Unhandled program action type %d", type); | ||
1150 | break; | ||
1151 | } | ||
1152 | |||
1153 | if (detail > 1) | ||
1154 | { | ||
1155 | double from, range; | ||
1156 | |||
1157 | from = edje_edit_program_transition_time_get(ed, program); | ||
1158 | if (from > 0.0) | ||
1159 | { | ||
1160 | str = _transition_name_get | ||
1161 | (edje_edit_program_transition_get(ed, program)); | ||
1162 | if (machine) | ||
1163 | printf("TRANSITION-NAME: %s\nTRANSITION-DURATION: %g\n", | ||
1164 | str, from); | ||
1165 | else printf(INDENT3 "transition: %s %g;\n", str, from); | ||
1166 | /* do not free str! */ | ||
1167 | } | ||
1168 | |||
1169 | from = edje_edit_program_in_from_get(ed, program); | ||
1170 | range = edje_edit_program_in_range_get(ed, program); | ||
1171 | if (FDIFF(from, 0.0) || FDIFF(range, 0.0)) | ||
1172 | { | ||
1173 | if (machine) | ||
1174 | printf("IN-FROM: %g\nIN-RANGE: %g\n", from, range); | ||
1175 | else printf(INDENT3 "in: %g %g;\n", from, range); | ||
1176 | } | ||
1177 | } | ||
1178 | |||
1179 | lst = edje_edit_program_targets_get(ed, program); | ||
1180 | EINA_LIST_FOREACH(lst, l, str) | ||
1181 | if (machine) printf("TARGET: %s\n", str); | ||
1182 | else printf(INDENT3 "target: \"%s\";\n", str); | ||
1183 | edje_edit_string_list_free(lst); | ||
1184 | |||
1185 | lst = edje_edit_program_afters_get(ed, program); | ||
1186 | EINA_LIST_FOREACH(lst, l, str) | ||
1187 | if (machine) printf("AFTER: %s\n", str); | ||
1188 | else printf(INDENT3 "after: \"%s\";\n", str); | ||
1189 | edje_edit_string_list_free(lst); | ||
1190 | |||
1191 | // TODO Support script {} | ||
1192 | } | ||
1193 | |||
1194 | if (machine) puts("PROGRAM-DETAILS-END"); | ||
1195 | } | ||
1196 | |||
1197 | static Eina_Bool | ||
1198 | _group_programs_list(Evas_Object *ed) | ||
1199 | { | ||
1200 | Eina_Bool found = EINA_FALSE; | ||
1201 | Eina_List *programs, *l; | ||
1202 | const char *name; | ||
1203 | |||
1204 | programs_begin(); | ||
1205 | |||
1206 | /* TODO: change programs to operate on their ID instead of names! | ||
1207 | * needs huge change in Edje_Edit.h | ||
1208 | */ | ||
1209 | WRN("listing only programs with names!"); | ||
1210 | programs = edje_edit_programs_list_get(ed); | ||
1211 | EINA_LIST_FOREACH(programs, l, name) | ||
1212 | { | ||
1213 | if (!matches(name, program)) | ||
1214 | { | ||
1215 | DBG("filter out program '%s': does not match '%s'", name, program); | ||
1216 | continue; | ||
1217 | } | ||
1218 | if (api_only) | ||
1219 | { | ||
1220 | if (!edje_edit_program_api_name_get(ed, name)) | ||
1221 | { | ||
1222 | DBG("filter out program '%s': not API.", name); | ||
1223 | continue; | ||
1224 | } | ||
1225 | } | ||
1226 | |||
1227 | found = EINA_TRUE; | ||
1228 | program_begin(name); | ||
1229 | program_details(ed, name); | ||
1230 | program_end(); | ||
1231 | } | ||
1232 | |||
1233 | programs_end(); | ||
1234 | return found; | ||
1235 | } | ||
1236 | |||
1237 | static int | ||
1238 | _list(const char *mode) | ||
1239 | { | ||
1240 | Eina_List *l; | ||
1241 | const char *name; | ||
1242 | int ret = 0; | ||
1243 | Eina_Bool found_group = EINA_FALSE; | ||
1244 | Eina_Bool req_part, found_part, req_prog, found_prog; | ||
1245 | |||
1246 | if ((!strcmp(mode, "parts")) || (!strcmp(mode, "groups"))) | ||
1247 | { | ||
1248 | req_part = EINA_TRUE; | ||
1249 | found_part = EINA_FALSE; | ||
1250 | } | ||
1251 | else | ||
1252 | { | ||
1253 | req_part = EINA_FALSE; | ||
1254 | found_part = EINA_TRUE; | ||
1255 | } | ||
1256 | |||
1257 | if ((!strcmp(mode, "programs")) || (!strcmp(mode, "groups"))) | ||
1258 | { | ||
1259 | req_prog = EINA_TRUE; | ||
1260 | found_prog = EINA_FALSE; | ||
1261 | } | ||
1262 | else | ||
1263 | { | ||
1264 | req_prog = EINA_FALSE; | ||
1265 | found_prog = EINA_TRUE; | ||
1266 | } | ||
1267 | |||
1268 | EINA_LIST_FOREACH(groups, l, name) | ||
1269 | { | ||
1270 | Evas_Object *ed; | ||
1271 | |||
1272 | if (!matches(name, group)) | ||
1273 | { | ||
1274 | DBG("filter out group '%s': does not match '%s'", name, group); | ||
1275 | continue; | ||
1276 | } | ||
1277 | |||
1278 | ed = edje_edit_object_add(ecore_evas_get(ee)); | ||
1279 | if (!edje_object_file_set(ed, file, name)) | ||
1280 | { | ||
1281 | Edje_Load_Error err = edje_object_load_error_get(ed); | ||
1282 | const char *errmsg = edje_load_error_str(err); | ||
1283 | ERR("could not load group '%s' from file '%s': %s", | ||
1284 | name, file, errmsg); | ||
1285 | evas_object_del(ed); | ||
1286 | continue; | ||
1287 | } | ||
1288 | |||
1289 | found_group = EINA_TRUE; | ||
1290 | group_begin(name); | ||
1291 | group_details(ed); | ||
1292 | |||
1293 | if (req_part) found_part |= _group_parts_list(ed); | ||
1294 | if (req_prog) found_prog |= _group_programs_list(ed); | ||
1295 | |||
1296 | group_end(); | ||
1297 | evas_object_del(ed); | ||
1298 | } | ||
1299 | |||
1300 | /* no hard requirement for parts or programs for group listing */ | ||
1301 | if (!strcmp(mode, "groups")) req_part = req_prog = EINA_FALSE; | ||
1302 | |||
1303 | if (!found_group) | ||
1304 | { | ||
1305 | WRN("no groups match '%s'", group); | ||
1306 | ret = 1; | ||
1307 | } | ||
1308 | if ((req_part) && (!found_part)) | ||
1309 | { | ||
1310 | WRN("no parts match '%s'", part); | ||
1311 | ret = 1; | ||
1312 | } | ||
1313 | if ((req_prog) && (!found_prog)) | ||
1314 | { | ||
1315 | WRN("no programs match '%s'", program); | ||
1316 | ret = 1; | ||
1317 | } | ||
1318 | return ret; | ||
1319 | } | ||
1320 | |||
1321 | static Evas_Object * | ||
1322 | _edje_object_any_get(void) | ||
1323 | { | ||
1324 | Evas_Object *ed = edje_edit_object_add(ecore_evas_get(ee)); | ||
1325 | Eina_List *l; | ||
1326 | const char *name; | ||
1327 | if (!ed) return NULL; | ||
1328 | EINA_LIST_FOREACH(groups, l, name) | ||
1329 | if (edje_object_file_set(ed, file, name)) return ed; | ||
1330 | evas_object_del(ed); | ||
1331 | return NULL; | ||
1332 | } | ||
1333 | |||
1334 | static Eina_Bool | ||
1335 | _gdata_list(void) | ||
1336 | { | ||
1337 | Evas_Object *ed = _edje_object_any_get(); | ||
1338 | Eina_List *l, *data; | ||
1339 | const char *key; | ||
1340 | |||
1341 | if (!ed) return EINA_FALSE; | ||
1342 | |||
1343 | data = edje_edit_data_list_get(ed); | ||
1344 | |||
1345 | if (machine) puts("DATA-BEGIN"); | ||
1346 | else puts("data {"); | ||
1347 | |||
1348 | EINA_LIST_FOREACH(data, l, key) | ||
1349 | { | ||
1350 | const char *value = edje_edit_data_value_get(ed, key); | ||
1351 | if (machine) printf("ITEM: \"%s\" \"%s\"\n", key, value); | ||
1352 | else printf(INDENT "item: \"%s\" \"%s\";\n", key, value); | ||
1353 | } | ||
1354 | |||
1355 | if (machine) puts("DATA-END"); | ||
1356 | else puts("}"); | ||
1357 | |||
1358 | edje_edit_string_list_free(data); | ||
1359 | evas_object_del(ed); | ||
1360 | return EINA_TRUE; | ||
1361 | } | ||
1362 | |||
1363 | static const char * | ||
1364 | _comp_str_get(Evas_Object *ed, const char *img) | ||
1365 | { | ||
1366 | static char buf[128]; | ||
1367 | Edje_Edit_Image_Comp type = edje_edit_image_compression_type_get(ed, img); | ||
1368 | int rate; | ||
1369 | |||
1370 | switch (type) | ||
1371 | { | ||
1372 | case EDJE_EDIT_IMAGE_COMP_RAW: | ||
1373 | return "RAW"; | ||
1374 | case EDJE_EDIT_IMAGE_COMP_USER: | ||
1375 | return "USER"; | ||
1376 | case EDJE_EDIT_IMAGE_COMP_COMP: | ||
1377 | return "COMP"; | ||
1378 | case EDJE_EDIT_IMAGE_COMP_LOSSY: | ||
1379 | rate = edje_edit_image_compression_rate_get(ed, img); | ||
1380 | snprintf(buf, sizeof(buf), "LOSSY %d", rate); | ||
1381 | return buf; | ||
1382 | default: | ||
1383 | ERR("Unknown compression type %d", type); | ||
1384 | return "???"; | ||
1385 | } | ||
1386 | } | ||
1387 | |||
1388 | static Eina_Bool | ||
1389 | _images_list(void) | ||
1390 | { | ||
1391 | Evas_Object *ed = _edje_object_any_get(); | ||
1392 | Eina_List *l, *images; | ||
1393 | const char *img; | ||
1394 | |||
1395 | if (!ed) return EINA_FALSE; | ||
1396 | |||
1397 | images = edje_edit_images_list_get(ed); | ||
1398 | |||
1399 | if (machine) puts("IMAGES-BEGIN"); | ||
1400 | else puts("images {"); | ||
1401 | |||
1402 | EINA_LIST_FOREACH(images, l, img) | ||
1403 | { | ||
1404 | int id = edje_edit_image_id_get(ed, img); | ||
1405 | const char *comp = _comp_str_get(ed, img); | ||
1406 | |||
1407 | if (detail < 1) | ||
1408 | { | ||
1409 | if (machine) printf("IMAGE: %s\n", img); | ||
1410 | else printf(INDENT "image: \"%s\" %s;\n", img, comp); | ||
1411 | } | ||
1412 | else if (detail == 1) | ||
1413 | { | ||
1414 | if (machine) printf("IMAGE: \"%s\" \"%s\"\n", img, comp); | ||
1415 | else printf(INDENT "image: \"%s\" %s;\n", img, comp); | ||
1416 | } | ||
1417 | else | ||
1418 | { | ||
1419 | if (machine) | ||
1420 | printf("IMAGE: \"edje/images/%d\" \"%s\" \"%s\"\n", | ||
1421 | id, img, comp); | ||
1422 | else | ||
1423 | printf(INDENT "image: \"%s\" %s; /* id: \"edje/images/%d\" */\n", | ||
1424 | img, comp, id); | ||
1425 | } | ||
1426 | } | ||
1427 | |||
1428 | if (machine) puts("IMAGES-END"); | ||
1429 | else puts("}"); | ||
1430 | |||
1431 | edje_edit_string_list_free(images); | ||
1432 | evas_object_del(ed); | ||
1433 | return EINA_TRUE; | ||
1434 | } | ||
1435 | |||
1436 | static Eina_Bool | ||
1437 | _fonts_list(void) | ||
1438 | { | ||
1439 | Evas_Object *ed = _edje_object_any_get(); | ||
1440 | Eina_List *l, *fonts; | ||
1441 | const char *alias; | ||
1442 | |||
1443 | if (!ed) return EINA_FALSE; | ||
1444 | |||
1445 | fonts = edje_edit_fonts_list_get(ed); | ||
1446 | |||
1447 | if (machine) puts("FONTS-BEGIN"); | ||
1448 | else puts("fonts {"); | ||
1449 | |||
1450 | EINA_LIST_FOREACH(fonts, l, alias) | ||
1451 | { | ||
1452 | const char *path = edje_edit_font_path_get(ed, alias); | ||
1453 | |||
1454 | if (detail < 1) | ||
1455 | { | ||
1456 | if (machine) printf("FONT: %s\n", alias); | ||
1457 | else printf(INDENT "font: \"%s\" \"%s\";\n", path, alias); | ||
1458 | } | ||
1459 | else if (detail == 1) | ||
1460 | { | ||
1461 | if (machine) printf("FONT: \"%s\" \"%s\"\n", path, alias); | ||
1462 | else printf(INDENT "font: \"%s\" \"%s\";\n", path, alias); | ||
1463 | } | ||
1464 | else | ||
1465 | { | ||
1466 | if (machine) | ||
1467 | printf("FONT: \"edje/fonts/%s\" \"%s\" \"%s\"\n", | ||
1468 | alias, path, alias); | ||
1469 | else | ||
1470 | printf(INDENT | ||
1471 | "font: \"%s\" \"%s\"; /* id: \"edje/fonts/%s\" */\n", | ||
1472 | path, alias, alias); | ||
1473 | } | ||
1474 | |||
1475 | edje_edit_string_free(path); | ||
1476 | } | ||
1477 | |||
1478 | if (machine) puts("FONTS-END"); | ||
1479 | else puts("}"); | ||
1480 | |||
1481 | edje_edit_string_list_free(fonts); | ||
1482 | evas_object_del(ed); | ||
1483 | return EINA_TRUE; | ||
1484 | } | ||
1485 | |||
1486 | static Eina_Bool | ||
1487 | _externals_list(void) | ||
1488 | { | ||
1489 | Evas_Object *ed = _edje_object_any_get(); | ||
1490 | Eina_List *l, *externals; | ||
1491 | const char *key; | ||
1492 | |||
1493 | if (!ed) return EINA_FALSE; | ||
1494 | |||
1495 | externals = edje_edit_externals_list_get(ed); | ||
1496 | |||
1497 | if (machine) puts("EXTERNALS-BEGIN"); | ||
1498 | else puts("externals {"); | ||
1499 | |||
1500 | EINA_LIST_FOREACH(externals, l, key) | ||
1501 | { | ||
1502 | if (machine) printf("EXTERNAL: %s\n", key); | ||
1503 | else printf(INDENT "external: \"%s\";\n", key); | ||
1504 | } | ||
1505 | |||
1506 | if (machine) puts("EXTERNALS-END"); | ||
1507 | else puts("}"); | ||
1508 | |||
1509 | edje_edit_string_list_free(externals); | ||
1510 | evas_object_del(ed); | ||
1511 | return EINA_TRUE; | ||
1512 | } | ||
1513 | |||
1514 | |||
1515 | int | ||
1516 | main(int argc, char **argv) | ||
1517 | { | ||
1518 | Eina_Bool quit_option = EINA_FALSE; | ||
1519 | char *mode = NULL; | ||
1520 | char *detail_name = NULL; | ||
1521 | int arg_index; | ||
1522 | int ret = 0; | ||
1523 | Ecore_Getopt_Value values[] = { | ||
1524 | ECORE_GETOPT_VALUE_STR(mode), | ||
1525 | ECORE_GETOPT_VALUE_STR(detail_name), | ||
1526 | ECORE_GETOPT_VALUE_STR(group), | ||
1527 | ECORE_GETOPT_VALUE_STR(part), | ||
1528 | ECORE_GETOPT_VALUE_STR(program), | ||
1529 | ECORE_GETOPT_VALUE_BOOL(api_only), | ||
1530 | ECORE_GETOPT_VALUE_BOOL(api_fix), | ||
1531 | ECORE_GETOPT_VALUE_BOOL(machine), | ||
1532 | ECORE_GETOPT_VALUE_BOOL(quit_option), | ||
1533 | ECORE_GETOPT_VALUE_BOOL(quit_option), | ||
1534 | ECORE_GETOPT_VALUE_BOOL(quit_option), | ||
1535 | ECORE_GETOPT_VALUE_BOOL(quit_option), | ||
1536 | ECORE_GETOPT_VALUE_NONE | ||
1537 | }; | ||
1538 | |||
1539 | setlocale(LC_NUMERIC, "C"); | ||
1540 | |||
1541 | ecore_init(); | ||
1542 | ecore_evas_init(); | ||
1543 | eina_init(); | ||
1544 | edje_init(); | ||
1545 | |||
1546 | _log_dom = eina_log_domain_register("edje_inspector", EINA_COLOR_YELLOW); | ||
1547 | if (_log_dom < 0) | ||
1548 | { | ||
1549 | EINA_LOG_CRIT("could not register log domain 'edje_inspector'"); | ||
1550 | ret = 1; | ||
1551 | goto error_log; | ||
1552 | } | ||
1553 | |||
1554 | arg_index = ecore_getopt_parse(&optdesc, values, argc, argv); | ||
1555 | if (arg_index < 0) | ||
1556 | { | ||
1557 | ERR("could not parse arguments."); | ||
1558 | ret = 1; | ||
1559 | goto error_getopt; | ||
1560 | } | ||
1561 | else if (quit_option) goto error_getopt; | ||
1562 | else if (arg_index != argc - 1) | ||
1563 | { | ||
1564 | ERR("incorrect number of parameters. Requires one single file."); | ||
1565 | ret = 1; | ||
1566 | goto error_getopt; | ||
1567 | } | ||
1568 | |||
1569 | if (!mode) mode = (char *)mode_choices[0]; | ||
1570 | |||
1571 | if (detail_name) | ||
1572 | { | ||
1573 | if (!strcmp(detail_name, "none")) detail = 0; | ||
1574 | else if (!strcmp(detail_name, "terse")) detail = 1; | ||
1575 | else if (!strcmp(detail_name, "all")) detail = 2; | ||
1576 | else ERR("Unknown detail level: '%s'", detail_name); | ||
1577 | } | ||
1578 | |||
1579 | file = argv[arg_index]; | ||
1580 | |||
1581 | // check if the file is accessible | ||
1582 | if (access(file, R_OK) == -1) | ||
1583 | { | ||
1584 | int e = errno; | ||
1585 | ERR("File '%s' not accessible, error %d (%s).\n", | ||
1586 | file, e, strerror(e)); | ||
1587 | ret = 1; | ||
1588 | goto error_getopt; | ||
1589 | } | ||
1590 | |||
1591 | DBG("mode=%s, detail=%d(%s), group=%s, part=%s, program=%s, api-only=" FMT_UCHAR | ||
1592 | ", api-fix=" FMT_UCHAR ", machine=" FMT_UCHAR ", file=%s", | ||
1593 | mode, detail, detail_name, | ||
1594 | group ? group : "", | ||
1595 | part ? part : "", | ||
1596 | program ? program : "", | ||
1597 | api_only, api_fix, machine, file); | ||
1598 | |||
1599 | |||
1600 | groups = edje_file_collection_list(file); | ||
1601 | if (!groups) | ||
1602 | { | ||
1603 | ERR("no groups in edje file '%s'", file); | ||
1604 | ret = 1; | ||
1605 | goto error_getopt; | ||
1606 | } | ||
1607 | |||
1608 | if (!strcmp(mode, "groups-names")) ret = _groups_names_list(); | ||
1609 | else | ||
1610 | { | ||
1611 | ee = ecore_evas_buffer_new(1, 1); | ||
1612 | if (!ee) | ||
1613 | { | ||
1614 | ERR("could not create ecore_evas_buffer"); | ||
1615 | ret = 1; | ||
1616 | } | ||
1617 | else | ||
1618 | { | ||
1619 | if (!strcmp(mode, "parts-names")) ret = _parts_names_list(); | ||
1620 | else if (!strcmp(mode, "global-data")) ret = _gdata_list(); | ||
1621 | else if (!strcmp(mode, "images")) ret = _images_list(); | ||
1622 | else if (!strcmp(mode, "fonts")) ret = _fonts_list(); | ||
1623 | else if (!strcmp(mode, "externals")) ret = _externals_list(); | ||
1624 | else ret = _list(mode); | ||
1625 | ecore_evas_free(ee); | ||
1626 | } | ||
1627 | } | ||
1628 | |||
1629 | edje_file_collection_list_free(groups); | ||
1630 | error_getopt: | ||
1631 | eina_log_domain_unregister(_log_dom); | ||
1632 | error_log: | ||
1633 | edje_shutdown(); | ||
1634 | ecore_evas_shutdown(); | ||
1635 | ecore_shutdown(); | ||
1636 | eina_shutdown(); | ||
1637 | |||
1638 | return ret; | ||
1639 | } | ||