efl

1
#ifdef HAVE_CONFIG_H
2
# include "config.h"
3
#endif
4

5
#include <locale.h>
6
#include <unistd.h>
7
#include <errno.h>
8

9
#include "Edje.h"
10
#define EDJE_EDIT_IS_UNSTABLE_AND_I_KNOW_ABOUT_IT 1
11
#include "Edje_Edit.h"
12

13
#include <Ecore.h>
14
#include <Ecore_Evas.h>
15
#include <Ecore_Getopt.h>
16

17
static int _log_dom;
18
#define DBG(...) EINA_LOG_DOM_DBG(_log_dom, __VA_ARGS__)
19
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
20
#define WRN(...) EINA_LOG_DOM_WARN(_log_dom, __VA_ARGS__)
21
#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
22
#define CRI(...) EINA_LOG_DOM_CRIT(_log_dom, __VA_ARGS__)
23

24
#define INDENT          "   "
25
#define INDENT2         INDENT INDENT
26
#define INDENT3         INDENT2 INDENT
27
#define INDENT4         INDENT3 INDENT
28
#define INDENT5         INDENT4 INDENT
29
#define INDENT6         INDENT5 INDENT
30
#define INDENT7         INDENT6 INDENT
31

32
#define FLOAT_PRECISION 0.0001
33
#define FDIFF(a, b) (fabs((a) - (b)) > FLOAT_PRECISION)
34

35
/* context */
36
static Eina_List *groups;
37
static Ecore_Evas *ee;
38

39
/* options */
40
static const char *file;
41
static char *group = NULL;
42
static char *part = NULL;
43
static char *program = NULL;
44
static int detail = 1;
45
static Eina_Bool api_only = EINA_FALSE;
46
static Eina_Bool api_fix = EINA_FALSE;
47
static Eina_Bool machine = EINA_FALSE;
48

49
static const char *mode_choices[] = {
50
   "groups",
51
   "parts",
52
   "programs",
53
   "groups-names",
54
   "part-names",
55
   "global-data",
56
   "images",
57
   "fonts",
58
   "externals",
59
   NULL,
60
};
61

62
static const char *detail_choices[] = {
63
   "none",
64
   "terse",
65
   "all",
66
   NULL
67
};
68

69
const Ecore_Getopt optdesc = {
70
   "edje_inspector",
71
   "%prog [options] <file.edj>",
72
   PACKAGE_VERSION,
73
   "(C) 2010 - The Enlightenment Project",
74
   "BSD",
75
   "Edje file inspector, let one see groups, parts, programs and other details "
76
   "of a compiled (binary) edje file.\n",
77
   0,
78
   {
79
      ECORE_GETOPT_CHOICE('m', "mode", "Choose which mode to operate on file.",
80
                          mode_choices),
81
      ECORE_GETOPT_CHOICE('d', "detail", "Choose detail level (default=terse)",
82
                          detail_choices),
83
      ECORE_GETOPT_STORE_STR('g', "group", "Limit output to group (or glob)."),
84
      ECORE_GETOPT_STORE_STR('p', "part", "Limit output to part (or glob)."),
85
      ECORE_GETOPT_STORE_STR('r', "program",
86
                             "Limit output to program (or glob)."),
87
      ECORE_GETOPT_STORE_TRUE('a', "api-only", "Limit to just api parts or "
88
                                               "programs."),
89
      ECORE_GETOPT_STORE_TRUE('A', "api-fix", "Fix API names to be C compliant."),
90
      ECORE_GETOPT_STORE_TRUE('M', "machine", "Produce machine readable output."),
91
      ECORE_GETOPT_LICENSE('L', "license"),
92
      ECORE_GETOPT_COPYRIGHT('C', "copyright"),
93
      ECORE_GETOPT_VERSION('V', "version"),
94
      ECORE_GETOPT_HELP('h', "help"),
95
      ECORE_GETOPT_SENTINEL
96
   }
97
};
98

99
static inline Eina_Bool
100
matches(const char *name, const char *pattern)
101
{
102
   if (!pattern) return EINA_TRUE;
103
   return eina_fnmatch(pattern, name, 0);
104
}
105

106
static void
107
group_begin(const char *name)
108
{
109
   if (machine) printf("GROUP-BEGIN\nNAME: %s\n", name);
110
   else printf("group { name: '%s';\n", name);
111
}
112

113
static void
114
group_end(void)
115
{
116
   if (machine) puts("GROUP-END");
117
   else puts("}");
118
}
119

120
static void
121
group_details(Evas_Object *ed)
122
{
123
   int w, h;
124

125
   if (detail < 1) return;
126

127
   if (machine) puts("GROUP-DETAILS-BEGIN");
128

129
   w = edje_edit_group_min_w_get(ed);
130
   h = edje_edit_group_min_h_get(ed);
131
   if (machine) printf("MIN-W: %d\nMIN-H: %d\n", w, h);
132
   else if ((w > 0) || (h > 0))
133
     printf(INDENT "min: %d %d;\n", w, h);
134

135
   w = edje_edit_group_max_w_get(ed);
136
   h = edje_edit_group_max_h_get(ed);
137
   if (machine) printf("MAX-W: %d\nMAX-H: %d\n", w, h);
138
   else if ((w > 0) || (h > 0))
139
     printf(INDENT "max: %d %d;\n", w, h);
140

141
   if (detail > 1)
142
     {
143
        Eina_List *dl;
144
        dl = edje_edit_group_data_list_get(ed);
145
        if (dl)
146
          {
147
             Eina_List *l;
148
             const char *k;
149
             if (machine) puts(INDENT "GROUP-DETAILS-DATA-BEGIN");
150
             else puts(INDENT "data {");
151

152
             EINA_LIST_FOREACH(dl, l, k)
153
               {
154
                  const char *v = edje_edit_group_data_value_get(ed, k);
155
                  if (machine) printf("ITEM: \"%s\" \"%s\"\n", k, v);
156
                  else printf(INDENT2 "item: \"%s\" \"%s\";\n", k, v);
157
               }
158

159
             edje_edit_string_list_free(dl);
160

161
             if (machine) puts(INDENT "GROUP-DETAILS-DATA-END");
162
             else puts(INDENT "}");
163
          }
164
     }
165

166
   if (machine) puts("GROUP-DETAILS-END");
167
}
168

169
static void
170
parts_begin(void)
171
{
172
   if (machine) puts("PARTS-BEGIN");
173
   else puts(INDENT "parts {");
174
}
175

176
static void
177
parts_end(void)
178
{
179
   if (machine) puts("PARTS-END");
180
   else puts(INDENT "}");
181
}
182

183
static const char *
184
part_type_name_get(Edje_Part_Type t)
185
{
186
   switch (t)
187
     {
188
      case EDJE_PART_TYPE_RECTANGLE:
189
        return "RECT";
190

191
      case EDJE_PART_TYPE_TEXT:
192
        return "TEXT";
193

194
      case EDJE_PART_TYPE_IMAGE:
195
        return "IMAGE";
196

197
      case EDJE_PART_TYPE_PROXY:
198
        return "PROXY";
199

200
      case EDJE_PART_TYPE_SWALLOW:
201
        return "SWALLOW";
202

203
      case EDJE_PART_TYPE_TEXTBLOCK:
204
        return "TEXTBLOCK";
205

206
      case EDJE_PART_TYPE_GRADIENT:
207
        return "GRADIENT";
208

209
      case EDJE_PART_TYPE_GROUP:
210
        return "GROUP";
211

212
      case EDJE_PART_TYPE_BOX:
213
        return "BOX";
214

215
      case EDJE_PART_TYPE_TABLE:
216
        return "TABLE";
217

218
      case EDJE_PART_TYPE_EXTERNAL:
219
        return "EXTERNAL";
220

221
      case EDJE_PART_TYPE_SPACER:
222
        return "SPACER";
223

224
      case EDJE_PART_TYPE_VECTOR:
225
        return "VECTOR";
226

227
      case EDJE_PART_TYPE_NONE:
228
      case EDJE_PART_TYPE_LAST:
229
        ERR("Invalid part type %d", t);
230
        return "???";
231

232
      default:
233
        ERR("Unknown part type %d", t);
234
        return "???";
235
     }
236
}
237

238
static void
239
state_begin(const char *state, double value)
240
{
241
   if (machine)
242
     printf("PART-STATE-BEGIN\nNAME: %s\nVALUE: %2.1f\n", state, value);
243
   else
244
     {
245
        printf(INDENT3 "description { state: \"%s\" %2.1f;", state, value);
246
        if (detail > 0) putchar('\n');
247
     }
248
}
249

250
static const char *
251
aspect_pref_name_get(int id)
252
{
253
   switch (id)
254
     {
255
      case 0: return "NONE";
256

257
      case 1: return "VERTICAL";
258

259
      case 2: return "HORIZONTAL";
260

261
      case 3: return "BOTH";
262

263
      default:
264
        ERR("Unknown aspect preference %d", id);
265
        return "???";
266
     }
267
}
268

269
static const char *
270
border_fill_name_get(int id)
271
{
272
   switch (id)
273
     {
274
      case 0: return "NONE";
275

276
      case 1: return "DEFAULT";
277

278
      case 2: return "SOLID";
279

280
      default:
281
        ERR("Unknown border fill %d", id);
282
        return "???";
283
     }
284
}
285

286
static void
287
state_details(Evas_Object *ed, const char *ppart, const char *state, double value)
288
{
289
   Edje_Part_Type t = edje_edit_part_type_get(ed, ppart);
290
   double dx, dy;
291
   const char *str, *str2;
292
   int x, y, r, g, b, a;
293

294
   if (detail < 1) return;
295

296
   b = edje_edit_state_visible_get(ed, ppart, state, value);
297
   if (machine) printf("VISIBLE: %d\n", b);
298
   else if (!b)
299
     puts(INDENT4 "visible: 0;");
300

301
   edje_edit_state_color_get(ed, ppart, state, value, &r, &g, &b, &a);
302
   if (machine)
303
     printf("COLOR-R: %d\nCOLOR-G: %d\nCOLOR-B: %d\nCOLOR-A: %d\n", r, g, b, a);
304
   else if ((r != 255) || (g != 255) || (b != 255) || (a != 255))
305
     printf(INDENT4 "color: %d %d %d %d;\n", r, g, b, a);
306

307
   if (detail > 1)
308
     {
309
        edje_edit_state_color2_get(ed, ppart, state, value, &r, &g, &b, &a);
310
        if (machine)
311
          printf("COLOR2-R: %d\nCOLOR2-G: %d\nCOLOR2-B: %d\nCOLOR2-A: %d\n",
312
                 r, g, b, a);
313
        else if ((r != 255) || (g != 255) || (b != 255) || (a != 255))
314
          printf(INDENT4 "color2: %d %d %d %d;\n", r, g, b, a);
315

316
        edje_edit_state_color3_get(ed, ppart, state, value, &r, &g, &b, &a);
317
        if (machine)
318
          printf("COLOR3-R: %d\nCOLOR3-G: %d\nCOLOR3-B: %d\nCOLOR3-A: %d\n",
319
                 r, g, b, a);
320
        else if ((r != 255) || (g != 255) || (b != 255) || (a != 255))
321
          printf(INDENT4 "color3: %d %d %d %d;\n", r, g, b, a);
322
     }
323

324
   dx = edje_edit_state_align_x_get(ed, ppart, state, value);
325
   dy = edje_edit_state_align_y_get(ed, ppart, state, value);
326
   if (machine) printf("ALIGN-X: %g\nALIGN-Y: %g\n", dx, dy);
327
   else if (FDIFF(dx, 0.5) || FDIFF(dy, 0.5))
328
     printf(INDENT4 "align: %g %g;\n", dx, dy);
329

330
   x = edje_edit_state_min_w_get(ed, ppart, state, value);
331
   y = edje_edit_state_min_h_get(ed, ppart, state, value);
332
   if (machine) printf("MIN-W: %d\nMIN-H: %d\n", x, y);
333
   else if ((x) || (y))
334
     printf(INDENT4 "min: %d %d;\n", x, y);
335

336
   x = edje_edit_state_max_w_get(ed, ppart, state, value);
337
   y = edje_edit_state_max_h_get(ed, ppart, state, value);
338
   if (machine) printf("MAX-W: %d\nMAX-H: %d\n", x, y);
339
   else if ((x != -1) || (y != -1))
340
     printf(INDENT4 "max: %d %d;\n", x, y);
341

342
   //TODO Support fixed
343
   //TODO Support step
344

345
   if (detail > 1)
346
     {
347
        dx = edje_edit_state_aspect_min_get(ed, ppart, state, value);
348
        dy = edje_edit_state_aspect_max_get(ed, ppart, state, value);
349
        if (machine) printf("ASPECT-MIN: %g\nASPECT-MAX: %g\n", dx, dy);
350
        else if (FDIFF(dx, 0.0) || FDIFF(dy, 0.0))
351
          printf(INDENT4 "aspect: %g %g;\n", dx, dy);
352

353
        x = edje_edit_state_aspect_pref_get(ed, ppart, state, value);
354
        str = aspect_pref_name_get(x);
355
        if (machine) printf("ASPECT-PREFERENCE: %s\n", str);
356
        else if (x)
357
          printf(INDENT4 "aspect_preference: %s;\n", str);
358
        /* do not free this str! */
359

360
        str = edje_edit_state_color_class_get(ed, ppart, state, value);
361
        if (machine) printf("COLOR_CLASS: %s\n", str ? str : "");
362
        else if (str)
363
          printf(INDENT4 "color_class: \"%s\";\n", str);
364
        edje_edit_string_free(str);
365
     }
366

367
   dx = edje_edit_state_rel1_relative_x_get(ed, ppart, state, value);
368
   dy = edje_edit_state_rel1_relative_y_get(ed, ppart, state, value);
369
   x = edje_edit_state_rel1_offset_x_get(ed, ppart, state, value);
370
   y = edje_edit_state_rel1_offset_y_get(ed, ppart, state, value);
371
   str = edje_edit_state_rel1_to_x_get(ed, ppart, state, value);
372
   str2 = edje_edit_state_rel1_to_y_get(ed, ppart, state, value);
373
   if (FDIFF(dx, 0.0) || FDIFF(dy, 0.0) || (x) || (y) || (str) || (str2))
374
     {
375
        if (machine) puts("REL1-BEGIN");
376
        else puts(INDENT4 "rel1 {");
377

378
        if (machine) printf("RELATIVE-X: %g\nRELATIVE-Y: %g\n", dx, dy);
379
        else if (FDIFF(dx, 0.0) || FDIFF(dy, 0.0))
380
          printf(INDENT5 "relative: %g %g;\n", dx, dy);
381

382
        if (machine) printf("OFFSET-X: %d\nOFFSET-Y: %d\n", x, y);
383
        else if ((x) || (y))
384
          printf(INDENT5 "offset: %d %d;\n", x, y);
385

386
        if (machine)
387
          printf("TO-X: %s\nTO-Y: %s\n", str ? str : "", str2 ? str2 : "");
388
        else if (((str) && (str2)) && (!strcmp(str, str2)))
389
          printf(INDENT5 "to: \"%s\";\n", str);
390
        else
391
          {
392
             if (str) printf(INDENT5 "to_x: \"%s\";\n", str);
393
             if (str2) printf(INDENT5 "to_y: \"%s\";\n", str2);
394
          }
395

396
        if (machine) puts("REL1-END");
397
        else puts(INDENT4 "}");
398
     }
399
   edje_edit_string_free(str);
400
   edje_edit_string_free(str2);
401

402
   dx = edje_edit_state_rel2_relative_x_get(ed, ppart, state, value);
403
   dy = edje_edit_state_rel2_relative_y_get(ed, ppart, state, value);
404
   x = edje_edit_state_rel2_offset_x_get(ed, ppart, state, value);
405
   y = edje_edit_state_rel2_offset_y_get(ed, ppart, state, value);
406
   str = edje_edit_state_rel2_to_x_get(ed, ppart, state, value);
407
   str2 = edje_edit_state_rel2_to_y_get(ed, ppart, state, value);
408
   if (FDIFF(dx, 1.0) || FDIFF(dy, 1.0) || (x != -1) || (y != -1) ||
409
       (str) || (str2))
410
     {
411
        if (machine) puts("REL2-BEGIN");
412
        else puts(INDENT4 "rel2 {");
413

414
        if (machine) printf("RELATIVE-X: %g\nRELATIVE-Y: %g\n", dx, dy);
415
        else if (FDIFF(dx, 1.0) || FDIFF(dy, 1.0))
416
          printf(INDENT5 "relative: %g %g;\n", dx, dy);
417

418
        if (machine) printf("OFFSET-X: %d\nOFFSET-Y: %d\n", x, y);
419
        else if ((x != -1) || (y != -1))
420
          printf(INDENT5 "offset: %d %d;\n", x, y);
421

422
        if (machine)
423
          printf("TO-X: %s\nTO-Y: %s\n", str ? str : "", str2 ? str2 : "");
424
        else if (((str) && (str2)) && (!strcmp(str, str2)))
425
          printf(INDENT5 "to: \"%s\";\n", str);
426
        else
427
          {
428
             if (str) printf(INDENT5 "to_x: \"%s\";\n", str);
429
             if (str2) printf(INDENT5 "to_y: \"%s\";\n", str2);
430
          }
431

432
        if (machine) puts("REL2-END");
433
        else puts(INDENT4 "}");
434
     }
435
   edje_edit_string_free(str);
436
   edje_edit_string_free(str2);
437

438
   if (t == EDJE_PART_TYPE_IMAGE)
439
     {
440
        str = edje_edit_state_image_get(ed, ppart, state, value);
441

442
        if (machine) printf("IMAGE-BEGIN\nNORMAL: %s\n", str ? str : "");
443
        else if (detail > 1)
444
          {
445
             puts(INDENT4 "image {");
446
             if (str) printf(INDENT5 "normal: \"%s\";\n", str);
447
          }
448
        else if (str)
449
          printf(INDENT4 "image.normal: \"%s\";\n", str);
450

451
        edje_edit_string_free(str);
452

453
        if (detail > 1)
454
          {
455
             Eina_List *tweens, *l;
456
             int bl, br, bt, bb, x2, y2;
457
             double dx2, dy2;
458
             Eina_Bool has_orgin, has_size;
459

460
             tweens = edje_edit_state_tweens_list_get(ed, ppart, state, value);
461
             EINA_LIST_FOREACH(tweens, l, str)
462
               {
463
                  if (machine) printf("TWEEN: %s\n", str);
464
                  else printf(INDENT5 "tween: \"%s\";\n", str);
465
               }
466
             edje_edit_string_list_free(tweens);
467

468
             edje_edit_state_image_border_get
469
               (ed, ppart, state, value, &bl, &br, &bt, &bb);
470
             if (machine)
471
               printf("BORDER-LEFT: %d\nBORDER-RIGHT: %d\n"
472
                      "BORDER-TOP: %d\nBORDER-BOTTOM: %d\n", bl, br, bt, bb);
473
             else if ((bl) || (br) || (bt) || (bb))
474
               printf(INDENT5 "border: %d %d %d %d;\n", bl, br, bt, bb);
475

476
             x = edje_edit_state_image_border_fill_get(ed, ppart, state, value);
477
             str = border_fill_name_get(x);
478
             if (machine) printf("BORDER-FILL: %s\n", str);
479
             else if (x != 1)
480
               printf(INDENT5 "middle: %s;\n", str);
481
             /* do not free str! */
482

483
             // TODO support image.fill.smooth
484

485
             dx = edje_edit_state_fill_origin_relative_x_get
486
                 (ed, ppart, state, value);
487
             dy = edje_edit_state_fill_origin_relative_y_get
488
                 (ed, ppart, state, value);
489
             x = edje_edit_state_fill_origin_offset_x_get
490
                 (ed, ppart, state, value);
491
             y = edje_edit_state_fill_origin_offset_y_get
492
                 (ed, ppart, state, value);
493

494
             dx2 = edje_edit_state_fill_size_relative_x_get
495
                 (ed, ppart, state, value);
496
             dy2 = edje_edit_state_fill_size_relative_y_get
497
                 (ed, ppart, state, value);
498
             x2 = edje_edit_state_fill_size_offset_x_get
499
                 (ed, ppart, state, value);
500
             y2 = edje_edit_state_fill_size_offset_y_get
501
                 (ed, ppart, state, value);
502

503
             has_orgin = (FDIFF(dx, 0.0) || FDIFF(dy, 0.0) || (x) || (y));
504
             has_size = (FDIFF(dx2, 1.0) || FDIFF(dy2, 1.0) || (x2) || (y2));
505

506
             if ((has_orgin) || (has_size))
507
               {
508
                  if (machine) puts("IMAGE-FILL-BEGIN");
509
                  else puts(INDENT5 "fill {");
510

511
                  if (has_orgin)
512
                    {
513
                       if (machine)
514
                         printf("ORIGIN-RELATIVE-X: %g\n"
515
                                "ORIGIN-RELATIVE-Y: %g\n"
516
                                "ORIGIN-OFFSET-X: %d\n"
517
                                "ORIGIN-OFFSET-Y: %d\n",
518
                                dx, dy, x, y);
519
                       else
520
                         printf(INDENT6 "origin {\n"
521
                                INDENT7 "relative: %g %g;\n"
522
                                INDENT7 "offset: %d %d;\n"
523
                                INDENT6 "}\n",
524
                                dx, dy, x, y);
525
                    }
526

527
                  if (has_size)
528
                    {
529
                       if (machine)
530
                         printf("SIZE-RELATIVE-X: %g\n"
531
                                "SIZE-RELATIVE-Y: %g\n"
532
                                "SIZE-OFFSET-X: %d\n"
533
                                "SIZE-OFFSET-Y: %d\n",
534
                                dx2, dy2, x2, y2);
535
                       else
536
                         printf(INDENT6 "size {\n"
537
                                INDENT7 "relative: %g %g;\n"
538
                                INDENT7 "offset: %d %d;\n"
539
                                INDENT6 "}\n",
540
                                dx2, dy2, x2, y2);
541
                    }
542

543
                  if (machine) puts("IMAGE-FILL-END");
544
                  else puts(INDENT5 "}");
545
               }
546
          }
547

548
        if (machine) puts("IMAGE-END");
549
        else if (detail > 1)
550
          puts(INDENT4 "}");
551
     }
552
   else if (t == EDJE_PART_TYPE_PROXY)
553
     {
554
        int x2, y2;
555
        double dx2, dy2;
556
        Eina_Bool has_orgin, has_size;
557

558
        if (machine) puts("PROXY-BEGIN");
559
        else puts(INDENT4 "proxy {");
560
        // TODO Support source
561
        // TODO support proxy.fill.smooth
562

563
        dx = edje_edit_state_fill_origin_relative_x_get
564
            (ed, ppart, state, value);
565
        dy = edje_edit_state_fill_origin_relative_y_get
566
            (ed, ppart, state, value);
567
        x = edje_edit_state_fill_origin_offset_x_get
568
            (ed, ppart, state, value);
569
        y = edje_edit_state_fill_origin_offset_y_get
570
            (ed, ppart, state, value);
571

572
        dx2 = edje_edit_state_fill_size_relative_x_get
573
            (ed, ppart, state, value);
574
        dy2 = edje_edit_state_fill_size_relative_y_get
575
            (ed, ppart, state, value);
576
        x2 = edje_edit_state_fill_size_offset_x_get
577
            (ed, ppart, state, value);
578
        y2 = edje_edit_state_fill_size_offset_y_get
579
            (ed, ppart, state, value);
580

581
        has_orgin = (FDIFF(dx, 0.0) || FDIFF(dy, 0.0) || (x) || (y));
582
        has_size = (FDIFF(dx2, 1.0) || FDIFF(dy2, 1.0) || (x2) || (y2));
583

584
        if ((has_orgin) || (has_size))
585
          {
586
             if (machine) puts("PROXY-FILL-BEGIN");
587
             else puts(INDENT5 "fill {");
588

589
             if (has_orgin)
590
               {
591
                  if (machine)
592
                    printf("ORIGIN-RELATIVE-X: %g\n"
593
                           "ORIGIN-RELATIVE-Y: %g\n"
594
                           "ORIGIN-OFFSET-X: %d\n"
595
                           "ORIGIN-OFFSET-Y: %d\n",
596
                           dx, dy, x, y);
597
                  else
598
                    printf(INDENT6 "origin {\n"
599
                           INDENT7 "relative: %g %g;\n"
600
                           INDENT7 "offset: %d %d;\n"
601
                           INDENT6 "}\n",
602
                           dx, dy, x, y);
603
               }
604

605
             if (has_size)
606
               {
607
                  if (machine)
608
                    printf("SIZE-RELATIVE-X: %g\n"
609
                           "SIZE-RELATIVE-Y: %g\n"
610
                           "SIZE-OFFSET-X: %d\n"
611
                           "SIZE-OFFSET-Y: %d\n",
612
                           dx2, dy2, x2, y2);
613
                  else
614
                    printf(INDENT6 "size {\n"
615
                           INDENT7 "relative: %g %g;\n"
616
                           INDENT7 "offset: %d %d;\n"
617
                           INDENT6 "}\n",
618
                           dx2, dy2, x2, y2);
619
               }
620

621
             if (machine) puts("PROXY-FILL-END");
622
             else puts(INDENT5 "}");
623
          }
624

625
        if (machine) puts("PROXY-END");
626
        else puts(INDENT4 "}");
627
     }
628
   else if ((t == EDJE_PART_TYPE_TEXTBLOCK) || (t == EDJE_PART_TYPE_TEXT))
629
     {
630
        if (machine) puts("TEXT-BEGIN");
631
        else puts(INDENT4 "text {");
632

633
        str = edje_edit_state_text_get(ed, ppart, state, value);
634
        if (machine) printf("TEXT: %s\n", str ? str : "");
635
        else if (str)
636
          printf(INDENT5 "text: \"%s\";\n", str);
637
        edje_edit_string_free(str);
638

639
        str = edje_edit_state_font_get(ed, ppart, state, value);
640
        if (machine) printf("FONT: %s\n", str ? str : "");
641
        else if (str)
642
          printf(INDENT5 "font: \"%s\";\n", str);
643
        edje_edit_string_free(str);
644

645
        x = edje_edit_state_text_size_get(ed, ppart, state, value);
646
        if (machine) printf("SIZE: %d\n", x);
647
        else if (x > 0)
648
          printf(INDENT5 "size: %d;\n", x);
649

650
        // TODO text_class
651

652
        dx = edje_edit_state_text_align_x_get(ed, ppart, state, value);
653
        dy = edje_edit_state_text_align_y_get(ed, ppart, state, value);
654
        if (machine) printf("TEXT-ALIGN-X: %g\nTEXT-ALIGN-Y: %g\n", dx, dy);
655
        else if (FDIFF(dx, 0.5) || FDIFF(dy, 0.5))
656
          printf(INDENT5 "align: %g %g;\n", dx, dy);
657

658
        x = edje_edit_state_text_fit_x_get(ed, ppart, state, value);
659
        y = edje_edit_state_text_fit_y_get(ed, ppart, state, value);
660
        if (machine) printf("TEXT-FIT-X: %d\nTEXT-FIT-Y: %d\n", x, y);
661
        else if ((x) || (y))
662
          printf(INDENT5 "fit: %d %d;\n", x, y);
663

664
        dx = edje_edit_state_text_elipsis_get(ed, ppart, state, value);
665
        if (machine) printf("TEXT-ELLIPSIS: %g\n", dx);
666
        else if (FDIFF(dx, 0.5))
667
          printf(INDENT5 "ellipsis: %g;\n", dx);
668

669
        if (machine) puts("TEXT-END");
670
        else puts(INDENT4 "}");
671
     }
672
   else if (t == EDJE_PART_TYPE_EXTERNAL)
673
     {
674
        const Eina_List *params, *l;
675
        const Edje_External_Param *p;
676

677
        params = edje_edit_state_external_params_list_get
678
            (ed, ppart, state, value);
679

680
        if (params)
681
          {
682
             if (machine) puts("PARAMS-BEGIN");
683
             else puts(INDENT4 "params {");
684

685
             EINA_LIST_FOREACH(params, l, p)
686
               switch (p->type)
687
                 {
688
                  case EDJE_EXTERNAL_PARAM_TYPE_INT:
689
                    printf(INDENT5 "int: \"%s\" \"%d\";\n", p->name, p->i);
690
                    break;
691

692
                  case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE:
693
                    printf(INDENT5 "double: \"%s\" \"%g\";\n", p->name, p->d);
694
                    break;
695

696
                  case EDJE_EXTERNAL_PARAM_TYPE_STRING:
697
                    if (p->s)
698
                      printf(INDENT5 "string: \"%s\" \"%s\";\n",
699
                             p->name, p->s);
700
                    break;
701

702
                  case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
703
                    printf(INDENT5 "bool: \"%s\" \"%d\";\n", p->name, p->i);
704
                    break;
705

706
                  case EDJE_EXTERNAL_PARAM_TYPE_CHOICE:
707
                    if (p->s)
708
                      printf(INDENT5 "choice: \"%s\" \"%s\";\n",
709
                             p->name, p->s);
710
                    break;
711

712
                  default:
713
                    break;
714
                 }
715

716
             if (machine) puts("PARAMS-END");
717
             else puts(INDENT4 "}");
718
          }
719
     }
720
}
721

722
static void
723
state_end(void)
724
{
725
   if (machine) puts("PART-STATE-END");
726
   else if (detail > 0)
727
     puts(INDENT3 "}");
728
   else puts(" }");
729
}
730

731
static void
732
part_begin(Evas_Object *ed, const char *name)
733
{
734
   const char *type = part_type_name_get(edje_edit_part_type_get(ed, name));
735
   if (machine) printf("PART-BEGIN\nNAME: %s\nTYPE: %s\n", name, type);
736
   else
737
     {
738
        printf(INDENT2 "part { name: '%s'; type: %s;", name, type);
739
        if (detail > 0) putchar('\n');
740
     }
741
}
742

743
static const char *
744
text_effect_name_get(Edje_Text_Effect effect)
745
{
746
   switch (effect)
747
     {
748
      case EDJE_TEXT_EFFECT_NONE:
749
        return "NONE";
750

751
      case EDJE_TEXT_EFFECT_PLAIN:
752
        return "PLAIN";
753

754
      case EDJE_TEXT_EFFECT_OUTLINE:
755
        return "OUTLINE";
756

757
      case EDJE_TEXT_EFFECT_SOFT_OUTLINE:
758
        return "SOFT_OUTLINE";
759

760
      case EDJE_TEXT_EFFECT_SHADOW:
761
        return "SHADOW";
762

763
      case EDJE_TEXT_EFFECT_SOFT_SHADOW:
764
        return "SOFT_SHADOW";
765

766
      case EDJE_TEXT_EFFECT_OUTLINE_SHADOW:
767
        return "OUTLINE_SHADOW";
768

769
      case EDJE_TEXT_EFFECT_OUTLINE_SOFT_SHADOW:
770
        return "OUTLINE_SOFT_SHADOW";
771

772
      case EDJE_TEXT_EFFECT_FAR_SHADOW:
773
        return "FAR_SHADOW";
774

775
      case EDJE_TEXT_EFFECT_FAR_SOFT_SHADOW:
776
        return "FAR_SOFT_SHADOW";
777

778
      case EDJE_TEXT_EFFECT_GLOW:
779
        return "GLOW";
780

781
      case EDJE_TEXT_EFFECT_LAST:
782
        ERR("Invalid part type %d", effect);
783
        return "???";
784

785
      default:
786
        ERR("Unknown effect type %d", effect);
787
        return "???";
788
     }
789
}
790

791
static inline Eina_Bool
792
_c_id_allowed(char c)
793
{
794
   if ((c >= '0') && (c <= '9')) return EINA_TRUE;
795
   if ((c >= 'a') && (c <= 'z')) return EINA_TRUE;
796
   if ((c >= 'A') && (c <= 'Z')) return EINA_TRUE;
797
   return EINA_FALSE;
798
}
799

800
static char *
801
_api_name_fix(const char *orig)
802
{
803
   char *d, *d_end, buf[256];
804
   const char *s;
805

806
   if (!orig) return NULL;
807
   if (!api_fix) return strdup(orig);
808

809
   s = orig;
810
   d = buf;
811
   d_end = d + sizeof(buf) - 1;
812
   for (; (*s != '\0') && (d < d_end); s++, d++)
813
     if (_c_id_allowed(*s)) *d = *s;
814
     else *d = '_';
815
   *d = '\0';
816

817
   return strdup(buf);
818
}
819

820
static char *
821
_part_api_name_get(Evas_Object *ed, const char *ppart)
822
{
823
   const char *orig = edje_edit_part_api_name_get(ed, ppart);
824
   char *fix = _api_name_fix(orig);
825
   edje_edit_string_free(orig);
826
   return fix;
827
}
828

829
static void
830
part_details(Evas_Object *ed, const char *ppart)
831
{
832
   Eina_List *states, *l;
833
   Eina_Bool b;
834
   const char *str, *str2;
835
   char *api;
836

837
   if (detail < 1) return;
838

839
   if (machine) puts("PART-DETAILS-BEGIN");
840

841
   str = api = _part_api_name_get(ed, ppart);
842
   str2 = edje_edit_part_api_description_get(ed, ppart);
843
   if (machine)
844
     {
845
        printf("API-NAME: %s\n", str ? str : "");
846
        printf("API-DESCRIPTION: %s\n", str2 ? str2 : "");
847
     }
848
   else if ((str) || (str2))
849
     printf(INDENT3 "api: \"%s\" \"%s\";\n", str ? str : "", str2 ? str2 : "");
850
   free(api);
851
   edje_edit_string_free(str2);
852

853
   b = edje_edit_part_mouse_events_get(ed, ppart);
854
   if (machine) printf("MOUSE_EVENTS: %d\n", b);
855
   else if (!b)
856
     puts(INDENT3 "mouse_events: 0;");
857

858
   if (detail > 1)
859
     {
860
        b = edje_edit_part_repeat_events_get(ed, ppart);
861
        if (machine) printf("REPEAT_EVENTS: %d\n", b);
862
        else if (b)
863
          puts(INDENT3 "repeat_events: 1;");
864

865
        b = edje_edit_part_scale_get(ed, ppart);
866
        if (machine) printf("SCALE: %d\n", b);
867
        else if (b)
868
          puts(INDENT3 "scale: 1;");
869
     }
870

871
   str = edje_edit_part_clip_to_get(ed, ppart);
872
   if (machine) printf("CLIP_TO: %s\n", str ? str : "");
873
   else if (str)
874
     printf(INDENT3 "clip_to: \"%s\";\n", str);
875
   edje_edit_string_free(str);
876

877
   str = edje_edit_part_source_get(ed, ppart);
878
   if (machine) printf("SOURCE: %s\n", str ? str : "");
879
   else if (str)
880
     printf(INDENT3 "source: \"%s\";\n", str);
881
   edje_edit_string_free(str);
882

883
   if (detail > 1)
884
     {
885
        if (edje_edit_part_type_get(ed, ppart) == EDJE_PART_TYPE_TEXT)
886
          {
887
             str = text_effect_name_get(edje_edit_part_effect_get(ed, ppart));
888
             if (machine) printf("EFFECT: %s\n", str ? str : "");
889
             else if (str)
890
               printf(INDENT3 "effect: %s;\n", str);
891
             /* do not free this str! */
892
          }
893

894
        if (edje_edit_part_drag_x_get(ed, ppart) ||
895
            edje_edit_part_drag_y_get(ed, ppart))
896
          {
897
             int dir, step, count;
898

899
             if (machine) puts("DRAGABLE-BEGIN");
900
             else puts(INDENT3 "dragable {");
901

902
             dir = edje_edit_part_drag_x_get(ed, ppart);
903
             step = edje_edit_part_drag_step_x_get(ed, ppart);
904
             count = edje_edit_part_drag_count_x_get(ed, ppart);
905
             if (machine) printf("DRAG-X: %d %d %d\n", dir, step, count);
906
             else printf(INDENT4 "x: %d %d %d;\n", dir, step, count);
907

908
             dir = edje_edit_part_drag_y_get(ed, ppart);
909
             step = edje_edit_part_drag_step_y_get(ed, ppart);
910
             count = edje_edit_part_drag_count_y_get(ed, ppart);
911
             if (machine) printf("DRAG-Y: %d %d %d\n", dir, step, count);
912
             else printf(INDENT4 "y: %d %d %d;\n", dir, step, count);
913

914
             str = edje_edit_part_drag_confine_get(ed, ppart);
915
             if (machine) printf("DRAG-CONFINE: %s\n", str ? str : "");
916
             else if (str)
917
               printf(INDENT4 "confine: \"%s\";\n", str);
918
             edje_edit_string_free(str);
919

920
             str = edje_edit_part_drag_event_get(ed, ppart);
921
             if (machine) printf("DRAG-EVENTS: %s\n", str ? str : "");
922
             else if (str)
923
               printf(INDENT4 "events: \"%s\";\n", str);
924
             edje_edit_string_free(str);
925

926
             if (machine) puts("DRAGABLE-END");
927
             else puts(INDENT3 "}");
928
          }
929
     }
930

931
   states = edje_edit_part_states_list_get(ed, ppart);
932
   EINA_LIST_FOREACH(states, l, str)
933
     {
934
        char state[512], *delim;
935
        double value;
936
        eina_strlcpy(state, str, sizeof(state)); /* bad states_list! :-( */
937
        delim = strchr(state, ' ');
938
        if (!delim) continue;
939
        *delim = '\0';
940
        delim++;
941
        value = strtod(delim, NULL);
942
        state_begin(state, value);
943
        state_details(ed, ppart, state, value);
944
        state_end();
945
     }
946
   edje_edit_string_list_free(states);
947

948
   if (machine) puts("PART-DETAILS-END");
949
}
950

951
static void
952
part_end(void)
953
{
954
   if (machine) puts("PART-END");
955
   else if (detail > 0)
956
     puts(INDENT2 "}");
957
   else puts(" }");
958
}
959

960
static int
961
_groups_names_list(void)
962
{
963
   Eina_List *l;
964
   const char *name;
965
   Eina_Bool found = EINA_FALSE;
966

967
   EINA_LIST_FOREACH(groups, l, name)
968
     {
969
        if (!matches(name, group))
970
          {
971
             DBG("filter out group '%s': does not match '%s'", name, group);
972
             continue;
973
          }
974
        found = EINA_TRUE;
975
        puts(name);
976
     }
977

978
   if (!found) WRN("no groups match '%s'", group);
979
   return !found;
980
}
981

982
static int
983
_parts_names_list(void)
984
{
985
   Eina_List *gl, *pl, *parts;
986
   const char *gname, *pname;
987
   Eina_Bool found_group = EINA_FALSE, found_part = EINA_FALSE;
988

989
   EINA_LIST_FOREACH(groups, gl, gname)
990
     {
991
        Evas_Object *ed;
992

993
        if (!matches(gname, group))
994
          {
995
             DBG("filter out group '%s': does not match '%s'", gname, group);
996
             continue;
997
          }
998

999
        ed = edje_edit_object_add(ecore_evas_get(ee));
1000
        if (!edje_object_file_set(ed, file, gname))
1001
          {
1002
             Edje_Load_Error err = edje_object_load_error_get(ed);
1003
             const char *errmsg = edje_load_error_str(err);
1004
             ERR("could not load group '%s' from file '%s': %s",
1005
                 gname, file, errmsg);
1006
             evas_object_del(ed);
1007
             continue;
1008
          }
1009

1010
        found_group = EINA_TRUE;
1011
        group_begin(gname);
1012

1013
        parts = edje_edit_parts_list_get(ed);
1014
        EINA_LIST_FOREACH(parts, pl, pname)
1015
          {
1016
             if (!matches(pname, part))
1017
               {
1018
                  DBG("filter out part '%s': does not match '%s'", pname, part);
1019
                  continue;
1020
               }
1021
             if (api_only)
1022
               {
1023
                  if (!edje_edit_part_api_name_get(ed, pname))
1024
                    {
1025
                       DBG("filter out part '%s': not API.", pname);
1026
                       continue;
1027
                    }
1028
               }
1029
             if (machine) printf("PART: %s\n", pname);
1030
             else printf(INDENT "part: %s\n", pname);
1031
          }
1032
        edje_edit_string_list_free(parts);
1033

1034
        group_end();
1035
        evas_object_del(ed);
1036
     }
1037

1038
   if (!found_group) WRN("no groups match '%s'", group);
1039
   if (!found_part) WRN("no parts match '%s'", part);
1040
   return (!found_group) || (!found_part);
1041
}
1042

1043
static Eina_Bool
1044
_group_parts_list(Evas_Object *ed)
1045
{
1046
   Eina_Bool found = EINA_FALSE;
1047
   Eina_List *parts, *l;
1048
   const char *name;
1049

1050
   parts_begin();
1051

1052
   parts = edje_edit_parts_list_get(ed);
1053
   EINA_LIST_FOREACH(parts, l, name)
1054
     {
1055
        if (!matches(name, part))
1056
          {
1057
             DBG("filter out part '%s': does not match '%s'", name, part);
1058
             continue;
1059
          }
1060
        if (api_only)
1061
          {
1062
             if (!edje_edit_part_api_name_get(ed, name))
1063
               {
1064
                  DBG("filter out part '%s': not API.", name);
1065
                  continue;
1066
               }
1067
          }
1068

1069
        found = EINA_TRUE;
1070
        part_begin(ed, name);
1071
        part_details(ed, name);
1072
        part_end();
1073
     }
1074

1075
   parts_end();
1076
   return found;
1077
}
1078

1079
static void
1080
programs_begin(void)
1081
{
1082
   if (machine) puts("PROGRAMS-BEGIN");
1083
   else puts(INDENT "programs {");
1084
}
1085

1086
static void
1087
programs_end(void)
1088
{
1089
   if (machine) puts("PROGRAMS-END");
1090
   else puts(INDENT "}");
1091
}
1092

1093
static void
1094
program_begin(const char *name)
1095
{
1096
   if (machine) printf("PROGRAM-BEGIN\nNAME: %s\n", name ? name : "");
1097
   else
1098
     {
1099
        printf(INDENT2 "program { name: '%s';\n", name ? name : "");
1100
     }
1101
}
1102

1103
static void
1104
program_end(void)
1105
{
1106
   if (machine) puts("PROGRAM-END");
1107
   else puts(INDENT2 "}");
1108
}
1109

1110
static char *
1111
_program_api_name_get(Evas_Object *ed, const char *pprogram)
1112
{
1113
   const char *orig = edje_edit_program_api_name_get(ed, pprogram);
1114
   char *fix = _api_name_fix(orig);
1115
   edje_edit_string_free(orig);
1116
   return fix;
1117
}
1118

1119
static const char *
1120
_transition_name_get(Edje_Tween_Mode mode)
1121
{
1122
   switch (mode)
1123
     {
1124
      case EDJE_TWEEN_MODE_LINEAR: return "LINEAR";
1125

1126
      case EDJE_TWEEN_MODE_ACCELERATE: return "ACCELERATE";
1127

1128
      case EDJE_TWEEN_MODE_DECELERATE: return "DECELERATE";
1129

1130
      case EDJE_TWEEN_MODE_SINUSOIDAL: return "SINUSOIDAL";
1131

1132
      case EDJE_TWEEN_MODE_CUBIC_BEZIER: return "CUBIC_BEZIER";
1133

1134
      default:
1135
        ERR("Unknown transition mode %d", mode);
1136
        return "???";
1137
     }
1138
}
1139

1140
static void
1141
program_details(Evas_Object *ed, const char *pprogram)
1142
{
1143
   const char *str, *str2;
1144
   char *api;
1145

1146
   if (detail < 1) return;
1147

1148
   if (machine) puts("PROGRAM-DETAILS-BEGIN");
1149

1150
   str = api = _program_api_name_get(ed, pprogram);
1151
   str2 = edje_edit_program_api_description_get(ed, pprogram);
1152
   if (machine)
1153
     {
1154
        printf("API-NAME: %s\n", str ? str : "");
1155
        printf("API-DESCRIPTION: %s\n", str2 ? str2 : "");
1156
     }
1157
   else if ((str) || (str2))
1158
     printf(INDENT3 "api: \"%s\" \"%s\";\n", str ? str : "", str2 ? str2 : "");
1159
   free(api);
1160
   edje_edit_string_free(str2);
1161

1162
   str = edje_edit_program_signal_get(ed, pprogram);
1163
   if (machine) printf("SIGNAL: %s\n", str ? str : "");
1164
   else if (str)
1165
     printf(INDENT3 "signal: \"%s\";\n", str);
1166
   edje_edit_string_free(str);
1167

1168
   str = edje_edit_program_source_get(ed, pprogram);
1169
   if (machine) printf("SOURCE: %s\n", str ? str : "");
1170
   else if (str)
1171
     printf(INDENT3 "source: \"%s\";\n", str);
1172
   edje_edit_string_free(str);
1173

1174
   if (detail >= 1)
1175
     {
1176
        Eina_List *lst, *l;
1177
        Edje_Action_Type type = edje_edit_program_action_get(ed, pprogram);
1178
        switch (type)
1179
          {
1180
           case EDJE_ACTION_TYPE_ACTION_STOP:
1181
             if (machine) puts("ACTION: ACTION_STOP");
1182
             else puts(INDENT3 "action: ACTION_STOP;");
1183
             break;
1184

1185
           case EDJE_ACTION_TYPE_STATE_SET:
1186
             str = edje_edit_program_state_get(ed, pprogram);
1187
             if (machine)
1188
               printf("ACTION: STATE_SET\nACTION-STATE: %s %g\n",
1189
                      str, edje_edit_program_value_get(ed, pprogram));
1190
             else
1191
               printf(INDENT3 "action: STATE_SET \"%s\" %2.1f;\n",
1192
                      str, edje_edit_program_value_get(ed, pprogram));
1193
             edje_edit_string_free(str);
1194
             break;
1195

1196
           case EDJE_ACTION_TYPE_SIGNAL_EMIT:
1197
             str = edje_edit_program_state_get(ed, pprogram);
1198
             str2 = edje_edit_program_state2_get(ed, pprogram);
1199
             if (machine)
1200
               printf("ACTION: SIGNAL_EMIT\nACTION-SIGNAL: %s\n"
1201
                      "ACTION-SOURCE: %s\n",
1202
                      str ? str : "", str2 ? str2 : "");
1203
             else if ((str) || (str2))
1204
               printf(INDENT3 "action: SIGNAL_EMIT \"%s\" \"%s\";\n",
1205
                      str ? str : "", str2 ? str2 : "");
1206
             edje_edit_string_free(str);
1207
             edje_edit_string_free(str2);
1208
             break;
1209

1210
           //TODO Support Drag
1211
           //~ case EDJE_ACTION_TYPE_DRAG_VAL_SET:
1212
           //~ eina_strbuf_append(buf, I4"action: DRAG_VAL_SET TODO;\n");
1213
           //~ break;
1214
           //~ case EDJE_ACTION_TYPE_DRAG_VAL_STEP:
1215
           //~ eina_strbuf_append(buf, I4"action: DRAG_VAL_STEP TODO;\n");
1216
           //~ break;
1217
           //~ case EDJE_ACTION_TYPE_DRAG_VAL_PAGE:
1218
           //~ eina_strbuf_append(buf, I4"action: DRAG_VAL_PAGE TODO;\n");
1219
           //~ break;
1220
           default:
1221
             ERR("Unhandled pprogram action type %d", type);
1222
             break;
1223
          }
1224

1225
        if (detail > 1)
1226
          {
1227
             double from, range;
1228

1229
             from = edje_edit_program_transition_time_get(ed, pprogram);
1230
             if (from > 0.0)
1231
               {
1232
                  str = _transition_name_get
1233
                      (edje_edit_program_transition_get(ed, pprogram));
1234
                  if (machine)
1235
                    printf("TRANSITION-NAME: %s\nTRANSITION-DURATION: %g\n",
1236
                           str, from);
1237
                  else printf(INDENT3 "transition: %s %g;\n", str, from);
1238
                  /* do not free str! */
1239
               }
1240

1241
             from = edje_edit_program_in_from_get(ed, pprogram);
1242
             range = edje_edit_program_in_range_get(ed, pprogram);
1243
             if (FDIFF(from, 0.0) || FDIFF(range, 0.0))
1244
               {
1245
                  if (machine)
1246
                    printf("IN-FROM: %g\nIN-RANGE: %g\n", from, range);
1247
                  else printf(INDENT3 "in: %g %g;\n", from, range);
1248
               }
1249
          }
1250

1251
        lst = edje_edit_program_targets_get(ed, pprogram);
1252
        EINA_LIST_FOREACH(lst, l, str)
1253
          if (machine) printf("TARGET: %s\n", str);
1254
          else printf(INDENT3 "target: \"%s\";\n", str);
1255
        edje_edit_string_list_free(lst);
1256

1257
        lst = edje_edit_program_afters_get(ed, pprogram);
1258
        EINA_LIST_FOREACH(lst, l, str)
1259
          if (machine) printf("AFTER: %s\n", str);
1260
          else printf(INDENT3 "after: \"%s\";\n", str);
1261
        edje_edit_string_list_free(lst);
1262

1263
        // TODO Support script {}
1264
     }
1265

1266
   if (machine) puts("PROGRAM-DETAILS-END");
1267
}
1268

1269
static Eina_Bool
1270
_group_programs_list(Evas_Object *ed)
1271
{
1272
   Eina_Bool found = EINA_FALSE;
1273
   Eina_List *programs, *l;
1274
   const char *name;
1275

1276
   programs_begin();
1277

1278
   /* TODO: change programs to operate on their ID instead of names!
1279
    * needs huge change in Edje_Edit.h
1280
    */
1281
   WRN("listing only programs with names!");
1282
   programs = edje_edit_programs_list_get(ed);
1283
   EINA_LIST_FOREACH(programs, l, name)
1284
     {
1285
        if (!matches(name, program))
1286
          {
1287
             DBG("filter out program '%s': does not match '%s'", name, program);
1288
             continue;
1289
          }
1290
        if (api_only)
1291
          {
1292
             if (!edje_edit_program_api_name_get(ed, name))
1293
               {
1294
                  DBG("filter out program '%s': not API.", name);
1295
                  continue;
1296
               }
1297
          }
1298

1299
        found = EINA_TRUE;
1300
        program_begin(name);
1301
        program_details(ed, name);
1302
        program_end();
1303
     }
1304

1305
   programs_end();
1306
   return found;
1307
}
1308

1309
static int
1310
_list(const char *mode)
1311
{
1312
   Eina_List *l;
1313
   const char *name;
1314
   int ret = 0;
1315
   Eina_Bool found_group = EINA_FALSE;
1316
   Eina_Bool req_part, found_part, req_prog, found_prog;
1317

1318
   if ((!strcmp(mode, "parts")) || (!strcmp(mode, "groups")))
1319
     {
1320
        req_part = EINA_TRUE;
1321
        found_part = EINA_FALSE;
1322
     }
1323
   else
1324
     {
1325
        req_part = EINA_FALSE;
1326
        found_part = EINA_TRUE;
1327
     }
1328

1329
   if ((!strcmp(mode, "programs")) || (!strcmp(mode, "groups")))
1330
     {
1331
        req_prog = EINA_TRUE;
1332
        found_prog = EINA_FALSE;
1333
     }
1334
   else
1335
     {
1336
        req_prog = EINA_FALSE;
1337
        found_prog = EINA_TRUE;
1338
     }
1339

1340
   EINA_LIST_FOREACH(groups, l, name)
1341
     {
1342
        Evas_Object *ed;
1343

1344
        if (!matches(name, group))
1345
          {
1346
             DBG("filter out group '%s': does not match '%s'", name, group);
1347
             continue;
1348
          }
1349

1350
        ed = edje_edit_object_add(ecore_evas_get(ee));
1351
        if (!edje_object_file_set(ed, file, name))
1352
          {
1353
             Edje_Load_Error err = edje_object_load_error_get(ed);
1354
             const char *errmsg = edje_load_error_str(err);
1355
             ERR("could not load group '%s' from file '%s': %s",
1356
                 name, file, errmsg);
1357
             evas_object_del(ed);
1358
             continue;
1359
          }
1360

1361
        found_group = EINA_TRUE;
1362
        group_begin(name);
1363
        group_details(ed);
1364

1365
        if (req_part) found_part |= _group_parts_list(ed);
1366
        if (req_prog) found_prog |= _group_programs_list(ed);
1367

1368
        group_end();
1369
        evas_object_del(ed);
1370
     }
1371

1372
   /* no hard requirement for parts or programs for group listing */
1373
   if (!strcmp(mode, "groups")) req_part = req_prog = EINA_FALSE;
1374

1375
   if (!found_group)
1376
     {
1377
        WRN("no groups match '%s'", group);
1378
        ret = 1;
1379
     }
1380
   if ((req_part) && (!found_part))
1381
     {
1382
        WRN("no parts match '%s'", part);
1383
        ret = 1;
1384
     }
1385
   if ((req_prog) && (!found_prog))
1386
     {
1387
        WRN("no programs match '%s'", program);
1388
        ret = 1;
1389
     }
1390
   return ret;
1391
}
1392

1393
static Evas_Object *
1394
_edje_object_any_get(void)
1395
{
1396
   Evas_Object *ed = edje_edit_object_add(ecore_evas_get(ee));
1397
   Eina_List *l;
1398
   const char *name;
1399
   if (!ed) return NULL;
1400
   EINA_LIST_FOREACH(groups, l, name)
1401
     if (edje_object_file_set(ed, file, name)) return ed;
1402
   evas_object_del(ed);
1403
   return NULL;
1404
}
1405

1406
static Eina_Bool
1407
_gdata_list(void)
1408
{
1409
   Evas_Object *ed = _edje_object_any_get();
1410
   Eina_List *l, *data;
1411
   const char *key;
1412

1413
   if (!ed) return EINA_FALSE;
1414

1415
   data = edje_edit_data_list_get(ed);
1416

1417
   if (machine) puts("DATA-BEGIN");
1418
   else puts("data {");
1419

1420
   EINA_LIST_FOREACH(data, l, key)
1421
     {
1422
        const char *value = edje_edit_data_value_get(ed, key);
1423
        if (machine) printf("ITEM: \"%s\" \"%s\"\n", key, value);
1424
        else printf(INDENT "item: \"%s\" \"%s\";\n", key, value);
1425
     }
1426

1427
   if (machine) puts("DATA-END");
1428
   else puts("}");
1429

1430
   edje_edit_string_list_free(data);
1431
   evas_object_del(ed);
1432
   return EINA_TRUE;
1433
}
1434

1435
static const char *
1436
_comp_str_get(Evas_Object *ed, const char *img)
1437
{
1438
   static char buf[128];
1439
   Edje_Edit_Image_Comp type = edje_edit_image_compression_type_get(ed, img);
1440
   int rate;
1441

1442
   switch (type)
1443
     {
1444
      case EDJE_EDIT_IMAGE_COMP_RAW:
1445
        return "RAW";
1446

1447
      case EDJE_EDIT_IMAGE_COMP_USER:
1448
        return "USER";
1449

1450
      case EDJE_EDIT_IMAGE_COMP_COMP:
1451
        return "COMP";
1452

1453
      case EDJE_EDIT_IMAGE_COMP_LOSSY:
1454
        rate = edje_edit_image_compression_rate_get(ed, img);
1455
        snprintf(buf, sizeof(buf), "LOSSY %d", rate);
1456
        return buf;
1457

1458
      case EDJE_EDIT_IMAGE_COMP_LOSSY_ETC1:
1459
        rate = edje_edit_image_compression_rate_get(ed, img);
1460
        snprintf(buf, sizeof(buf), "LOSSY_ETC1 %d", rate);
1461
        return buf;
1462

1463
      case EDJE_EDIT_IMAGE_COMP_LOSSY_ETC2:
1464
        rate = edje_edit_image_compression_rate_get(ed, img);
1465
        snprintf(buf, sizeof(buf), "LOSSY_ETC2 %d", rate);
1466
        return buf;
1467

1468
      default:
1469
        ERR("Unknown compression type %d", type);
1470
        return "???";
1471
     }
1472
}
1473

1474
static Eina_Bool
1475
_images_list(void)
1476
{
1477
   Evas_Object *ed = _edje_object_any_get();
1478
   Eina_List *l, *images;
1479
   const char *img;
1480

1481
   if (!ed) return EINA_FALSE;
1482

1483
   images = edje_edit_images_list_get(ed);
1484

1485
   if (machine) puts("IMAGES-BEGIN");
1486
   else puts("images {");
1487

1488
   EINA_LIST_FOREACH(images, l, img)
1489
     {
1490
        int id = edje_edit_image_id_get(ed, img);
1491
        const char *comp = _comp_str_get(ed, img);
1492

1493
        if (detail < 1)
1494
          {
1495
             if (machine) printf("IMAGE: %s\n", img);
1496
             else printf(INDENT "image: \"%s\" %s;\n", img, comp);
1497
          }
1498
        else if (detail == 1)
1499
          {
1500
             if (machine) printf("IMAGE: \"%s\" \"%s\"\n", img, comp);
1501
             else printf(INDENT "image: \"%s\" %s;\n", img, comp);
1502
          }
1503
        else
1504
          {
1505
             if (machine)
1506
               printf("IMAGE: \"edje/images/%d\" \"%s\" \"%s\"\n",
1507
                      id, img, comp);
1508
             else
1509
               printf(INDENT "image: \"%s\" %s; /* id: \"edje/images/%d\" */\n",
1510
                      img, comp, id);
1511
          }
1512
     }
1513

1514
   if (machine) puts("IMAGES-END");
1515
   else puts("}");
1516

1517
   edje_edit_string_list_free(images);
1518
   evas_object_del(ed);
1519
   return EINA_TRUE;
1520
}
1521

1522
static Eina_Bool
1523
_fonts_list(void)
1524
{
1525
   Evas_Object *ed = _edje_object_any_get();
1526
   Eina_List *l, *fonts;
1527
   const char *alias;
1528

1529
   if (!ed) return EINA_FALSE;
1530

1531
   fonts = edje_edit_fonts_list_get(ed);
1532

1533
   if (machine) puts("FONTS-BEGIN");
1534
   else puts("fonts {");
1535

1536
   EINA_LIST_FOREACH(fonts, l, alias)
1537
     {
1538
        const char *path = edje_edit_font_path_get(ed, alias);
1539

1540
        if (detail < 1)
1541
          {
1542
             if (machine) printf("FONT: %s\n", alias);
1543
             else printf(INDENT "font: \"%s\" \"%s\";\n", path, alias);
1544
          }
1545
        else if (detail == 1)
1546
          {
1547
             if (machine) printf("FONT: \"%s\" \"%s\"\n", path, alias);
1548
             else printf(INDENT "font: \"%s\" \"%s\";\n", path, alias);
1549
          }
1550
        else
1551
          {
1552
             if (machine)
1553
               printf("FONT: \"edje/fonts/%s\" \"%s\" \"%s\"\n",
1554
                      alias, path, alias);
1555
             else
1556
               printf(INDENT
1557
                      "font: \"%s\" \"%s\"; /* id: \"edje/fonts/%s\" */\n",
1558
                      path, alias, alias);
1559
          }
1560

1561
        edje_edit_string_free(path);
1562
     }
1563

1564
   if (machine) puts("FONTS-END");
1565
   else puts("}");
1566

1567
   edje_edit_string_list_free(fonts);
1568
   evas_object_del(ed);
1569
   return EINA_TRUE;
1570
}
1571

1572
static Eina_Bool
1573
_externals_list(void)
1574
{
1575
   Evas_Object *ed = _edje_object_any_get();
1576
   Eina_List *l, *externals;
1577
   const char *key;
1578

1579
   if (!ed) return EINA_FALSE;
1580

1581
   externals = edje_edit_externals_list_get(ed);
1582

1583
   if (machine) puts("EXTERNALS-BEGIN");
1584
   else puts("externals {");
1585

1586
   EINA_LIST_FOREACH(externals, l, key)
1587
     {
1588
        if (machine) printf("EXTERNAL: %s\n", key);
1589
        else printf(INDENT "external: \"%s\";\n", key);
1590
     }
1591

1592
   if (machine) puts("EXTERNALS-END");
1593
   else puts("}");
1594

1595
   edje_edit_string_list_free(externals);
1596
   evas_object_del(ed);
1597
   return EINA_TRUE;
1598
}
1599

1600
int
1601
main(int argc, char **argv)
1602
{
1603
   Eina_Bool quit_option = EINA_FALSE;
1604
   char *mode = NULL;
1605
   char *detail_name = NULL;
1606
   int arg_index;
1607
   int ret = 0;
1608
   Ecore_Getopt_Value values[] = {
1609
      ECORE_GETOPT_VALUE_STR(mode),
1610
      ECORE_GETOPT_VALUE_STR(detail_name),
1611
      ECORE_GETOPT_VALUE_STR(group),
1612
      ECORE_GETOPT_VALUE_STR(part),
1613
      ECORE_GETOPT_VALUE_STR(program),
1614
      ECORE_GETOPT_VALUE_BOOL(api_only),
1615
      ECORE_GETOPT_VALUE_BOOL(api_fix),
1616
      ECORE_GETOPT_VALUE_BOOL(machine),
1617
      ECORE_GETOPT_VALUE_BOOL(quit_option),
1618
      ECORE_GETOPT_VALUE_BOOL(quit_option),
1619
      ECORE_GETOPT_VALUE_BOOL(quit_option),
1620
      ECORE_GETOPT_VALUE_BOOL(quit_option),
1621
      ECORE_GETOPT_VALUE_NONE
1622
   };
1623

1624
   setlocale(LC_NUMERIC, "C");
1625

1626
   ecore_app_no_system_modules();
1627

1628
   ecore_init();
1629
   ecore_evas_init();
1630
   eina_init();
1631
   edje_init();
1632

1633
   _log_dom = eina_log_domain_register("edje_inspector", EINA_COLOR_YELLOW);
1634
   if (_log_dom < 0)
1635
     {
1636
        EINA_LOG_CRIT("could not register log domain 'edje_inspector'");
1637
        ret = 1;
1638
        goto error_log;
1639
     }
1640

1641
   arg_index = ecore_getopt_parse(&optdesc, values, argc, argv);
1642
   if (arg_index < 0)
1643
     {
1644
        ERR("could not parse arguments.");
1645
        ret = 1;
1646
        goto error_getopt;
1647
     }
1648
   else if (quit_option)
1649
     goto error_getopt;
1650
   else if (arg_index != argc - 1)
1651
     {
1652
        ERR("incorrect number of parameters. Requires one single file.");
1653
        ret = 1;
1654
        goto error_getopt;
1655
     }
1656

1657
   if (!mode) mode = (char *)mode_choices[0];
1658

1659
   if (detail_name)
1660
     {
1661
        if (!strcmp(detail_name, "none")) detail = 0;
1662
        else if (!strcmp(detail_name, "terse"))
1663
          detail = 1;
1664
        else if (!strcmp(detail_name, "all"))
1665
          detail = 2;
1666
        else ERR("Unknown detail level: '%s'", detail_name);
1667
     }
1668

1669
   file = argv[arg_index];
1670

1671
   // check if the file is accessible
1672
   if (access(file, R_OK) == -1)
1673
     {
1674
        int e = errno;
1675
        ERR("File '%s' not accessible, error %d (%s).\n",
1676
            file, e, strerror(e));
1677
        ret = 1;
1678
        goto error_getopt;
1679
     }
1680

1681
   DBG("mode=%s, detail=%d(%s), group=%s, part=%s, program=%s, api-only=%hhu"
1682
       ", api-fix=%hhu, machine=%hhu, file=%s",
1683
       mode, detail, detail_name,
1684
       group ? group : "",
1685
       part ? part : "",
1686
       program ? program : "",
1687
       api_only, api_fix, machine, file);
1688

1689
   groups = edje_file_collection_list(file);
1690
   if (!groups)
1691
     {
1692
        ERR("no groups in edje file '%s'", file);
1693
        ret = 1;
1694
        goto error_getopt;
1695
     }
1696

1697
   if (!strcmp(mode, "groups-names")) ret = _groups_names_list();
1698
   else
1699
     {
1700
        ee = ecore_evas_buffer_new(1, 1);
1701
        if (!ee)
1702
          {
1703
             ERR("could not create ecore_evas_buffer");
1704
             ret = 1;
1705
          }
1706
        else
1707
          {
1708
             if (!strcmp(mode, "parts-names")) ret = _parts_names_list();
1709
             else if (!strcmp(mode, "global-data"))
1710
               ret = _gdata_list();
1711
             else if (!strcmp(mode, "images"))
1712
               ret = _images_list();
1713
             else if (!strcmp(mode, "fonts"))
1714
               ret = _fonts_list();
1715
             else if (!strcmp(mode, "externals"))
1716
               ret = _externals_list();
1717
             else ret = _list(mode);
1718
             ecore_evas_free(ee);
1719
          }
1720
     }
1721

1722
   edje_file_collection_list_free(groups);
1723
error_getopt:
1724
   eina_log_domain_unregister(_log_dom);
1725
error_log:
1726
   edje_shutdown();
1727
   ecore_evas_shutdown();
1728
   ecore_shutdown();
1729
   eina_shutdown();
1730

1731
   return ret;
1732
}
1733

1734