You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1229 lines
38 KiB

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <ctype.h>
#include <fcntl.h>
#include <locale.h>
#include <unistd.h>
#include <errno.h>
#include <Eina.h>
#include <Ecore.h>
#include <Ecore_Getopt.h>
#include <Ecore_Evas.h>
#include "Edje.h"
#define EDJE_EDIT_IS_UNSTABLE_AND_I_KNOW_ABOUT_IT 1
#include "Edje_Edit.h"
static int _log_dom;
#define DBG(...) EINA_LOG_DOM_DBG(_log_dom, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
static Ecore_Evas *ee = NULL;
static char *file = NULL;
static char *group = NULL;
static char *prefix = NULL;
static FILE *source_fd = NULL;
static FILE *header_fd = NULL;
static Eina_List *externals = NULL;
#define H_HEADER \
"#ifndef _%s\n" \
"#define _%s\n\n" \
"#include <Edje.h>\n" \
"#include <Evas.h>\n\n" \
"#include <stdlib.h>\n\n"
#define H_FOOTER \
"\n#endif /* _%s */\n"
#define C_HEADER \
"#include \"%s\"\n\n"
#define C_CODEGEN_OBJECT_ADD \
"Evas_Object *\n" \
"%s_object_add(Evas *e, const char *file)\n" \
"{\n" \
" Evas_Object *o;\n\n" \
" o = edje_object_add(e);\n" \
" if (!o) return NULL;\n\n" \
" if (file)\n" \
" edje_object_file_set(o, file, \"%s\");\n" \
" else\n" \
" edje_object_file_set(o, \"%s\", \"%s\");\n\n" \
" return o;\n" \
"}\n\n"
#define H_CODEGEN_OBJECT_ADD \
"/**\n * @brief Creates the Edje object and set the edj file\n" \
" * @param e The surface\n" \
" * @param file The path to edj, if NULL it's used the path given\n" \
" * to edje_codegen\n */\n" \
"Evas_Object *%s_object_add(Evas *e, const char *file);\n\n"
#define C_CODEGEN_DRAG_SET(option) \
"Eina_Bool\n" \
"%s_%s_drag_"#option"_set(Evas_Object *o, double dx, double dy)\n" \
"{\n" \
" return edje_object_part_drag_"#option"_set(o, \"%s\", dx, dy);\n" \
"}\n\n"
#define H_CODEGEN_DRAG_SET(option) \
"Eina_Bool %s_%s_drag_"#option"_set(Evas_Object *o, double dx, double dy);\n"
#define C_CODEGEN_DRAG_GET(option) \
"Eina_Bool\n" \
"%s_%s_drag_"#option"_get(Evas_Object *o, double *dx, double *dy)\n" \
"{\n" \
" return edje_object_part_drag_"#option"_get(o, \"%s\", dx, dy);\n" \
"}\n\n"
#define H_CODEGEN_DRAG_GET(option) \
"Eina_Bool %s_%s_drag_"#option"_get(Evas_Object *o, double *dx" \
", double *dy);\n"
#define C_CODEGEN_DRAG_ACTION(option) \
"Eina_Bool\n" \
"%s_%s_drag_"#option"(Evas_Object *o, double dx, double dy)\n" \
"{\n" \
" return edje_object_part_drag_"#option"(o, \"%s\", dx, dy);\n" \
"}\n\n"
#define H_CODEGEN_DRAG_ACTION(option) \
"Eina_Bool %s_%s_drag_"#option"(Evas_Object *o, double dx, double dy);\n"
#define C_CODEGEN_DRAG_DIR_GET \
"Edje_Drag_Dir\n" \
"%s_%s_drag_dir_get(Evas_Object *o)\n" \
"{\n" \
" return edje_object_part_drag_dir_get(o, \"%s\");\n" \
"}\n\n"
#define H_CODEGEN_DRAG_DIR_GET \
"Edje_Drag_Dir %s_%s_drag_dir_get(Evas_Object *o);\n"
#define C_CODEGEN_PART_TEXT_SET \
"void\n" \
"%s_%s_set(Evas_Object *o, const char *value)\n" \
"{\n" \
" edje_object_part_text_set(o, \"%s\", value);\n" \
"}\n\n"
#define H_CODEGEN_PART_TEXT_SET \
"void %s_%s_set(Evas_Object *o, const char *value);\n"
#define C_CODEGEN_PART_SWALLOW_SET \
"void\n" \
"%s_%s_set(Evas_Object *o, Evas_Object *value)\n" \
"{\n" \
" edje_object_part_swallow(o, \"%s\", value);\n" \
"}\n\n"
#define H_CODEGEN_PART_SWALLOW_SET \
"void %s_%s_set(Evas_Object *o, Evas_Object *value);\n"
#define C_CODEGEN_PART_TEXT_GET \
"const char *\n" \
"%s_%s_get(const Evas_Object *o)\n" \
"{\n" \
" return edje_object_part_text_get(o, \"%s\");\n" \
"}\n\n"
#define H_CODEGEN_PART_TEXT_GET \
"const char *%s_%s_get(const Evas_Object *o);\n"
#define C_CODEGEN_PART_SWALLOW_GET \
"Evas_Object *\n" \
"%s_%s_get(const Evas_Object *o)\n" \
"{\n" \
" return edje_object_part_swallow_get(o, \"%s\");\n" \
"}\n\n"
#define H_CODEGEN_PART_SWALLOW_GET \
"Evas_Object *%s_%s_get(const Evas_Object *o);\n"
#define C_CODEGEN_PART_BOX_APPEND \
"Eina_Bool\n" \
"%s_%s_append(Evas_Object *o, Evas_Object *child)\n" \
"{\n" \
" return edje_object_part_box_append(o, \"%s\", child);\n" \
"}\n\n"
#define H_CODEGEN_PART_BOX_APPEND \
"Eina_Bool %s_%s_append(Evas_Object *o, Evas_Object *child);\n"
#define C_CODEGEN_PART_BOX_PREPEND \
"Eina_Bool\n" \
"%s_%s_prepend(Evas_Object *o, Evas_Object *child)\n" \
"{\n" \
" return edje_object_part_box_prepend(o, \"%s\", child);\n" \
"}\n\n"
#define H_CODEGEN_PART_BOX_PREPEND \
"Eina_Bool %s_%s_prepend(Evas_Object *o, Evas_Object *child);\n"
#define C_CODEGEN_PART_BOX_INSERT_BEFORE \
"Eina_Bool\n" \
"%s_%s_insert_before(Evas_Object *o, Evas_Object *child, " \
"const Evas_Object *reference)\n" \
"{\n" \
" return edje_object_part_box_insert_before(o, \"%s\", " \
"child, reference);\n" \
"}\n\n"
#define H_CODEGEN_PART_BOX_INSERT_BEFORE \
"Eina_Bool %s_%s_insert_before(Evas_Object *o, Evas_Object *child, " \
"const Evas_Object *reference);\n"
#define C_CODEGEN_PART_BOX_INSERT_AT \
"Eina_Bool\n" \
"%s_%s_insert_at(Evas_Object *o, Evas_Object *child, unsigned int pos)\n" \
"{\n" \
" return edje_object_part_box_insert_at(o, \"%s\", child, pos);\n" \
"}\n\n"
#define H_CODEGEN_PART_BOX_INSERT_AT \
"Eina_Bool %s_%s_insert_at(Evas_Object *o, Evas_Object *child, " \
"unsigned int pos);\n"
#define C_CODEGEN_PART_BOX_REMOVE \
"Evas_Object *\n" \
"%s_%s_remove(Evas_Object *o, Evas_Object *child)\n" \
"{\n" \
" return edje_object_part_box_remove(o, \"%s\", child);\n" \
"}\n\n"
#define H_CODEGEN_PART_BOX_REMOVE \
"Evas_Object *%s_%s_remove(Evas_Object *o, Evas_Object *child);\n"
#define C_CODEGEN_PART_BOX_REMOVE_AT \
"Evas_Object *\n" \
"%s_%s_remove_at(Evas_Object *o, unsigned int pos)\n" \
"{\n" \
" return edje_object_part_box_remove_at(o, \"%s\", pos);\n" \
"}\n\n"
#define H_CODEGEN_PART_BOX_REMOVE_AT \
"Evas_Object *%s_%s_remove_at(Evas_Object *o, unsigned int pos);\n"
#define C_CODEGEN_PART_BOX_REMOVE_ALL \
"Eina_Bool\n" \
"%s_%s_remove_all(Evas_Object *o, Eina_Bool clear)\n" \
"{\n" \
" return edje_object_part_box_remove_all(o, \"%s\", clear);\n" \
"}\n\n"
#define H_CODEGEN_PART_BOX_REMOVE_ALL \
"Eina_Bool %s_%s_remove_all(Evas_Object *o, Eina_Bool clear);\n"
#define C_CODEGEN_PART_TABLE_CHILD_GET \
"Evas_Object *\n" \
"%s_%s_child_get(Evas_Object *o, unsigned int col, unsigned int row)\n" \
"{\n" \
" return edje_object_part_table_child_get(o, \"%s\", col, row);\n" \
"}\n\n"
#define H_CODEGEN_PART_TABLE_CHILD_GET \
"Evas_Object * %s_%s_child_get(Evas_Object *o, unsigned int col, " \
"unsigned int row);\n"
#define C_CODEGEN_PART_TABLE_PACK \
"Eina_Bool\n" \
"%s_%s_pack(Evas_Object *o, Evas_Object *child, unsigned short col, " \
"unsigned short row, unsigned short colspan, unsigned short rowspan)\n" \
"{\n" \
" return edje_object_part_table_pack(o, \"%s\", child, col, row, " \
"colspan, rowspan);\n" \
"}\n\n"
#define H_CODEGEN_PART_TABLE_PACK \
"Eina_Bool %s_%s_pack(Evas_Object *o, Evas_Object *child, " \
"unsigned short col, unsigned short row, unsigned short " \
"colspan, unsigned short rowspan);\n"
#define C_CODEGEN_PART_TABLE_UNPACK \
"Eina_Bool\n" \
"%s_%s_unpack(Evas_Object *o, Evas_Object *child)\n" \
"{\n" \
" return edje_object_part_table_unpack(o, \"%s\", child);\n" \
"}\n\n"
#define H_CODEGEN_PART_TABLE_UNPACK \
"Eina_Bool %s_%s_unpack(Evas_Object *o, Evas_Object *child);\n"
#define C_CODEGEN_PART_TABLE_CLEAR \
"Eina_Bool\n" \
"%s_%s_clear(Evas_Object *o, Eina_Bool clear)\n" \
"{\n" \
" return edje_object_part_table_clear(o, \"%s\", clear);\n" \
"}\n\n"
#define H_CODEGEN_PART_TABLE_CLEAR \
"Eina_Bool %s_%s_clear(Evas_Object *o, Eina_Bool clear);\n"
#define C_CODEGEN_PART_TABLE_COL_ROW_SIZE_GET \
"Eina_Bool\n" \
"%s_%s_col_row_size_get(Evas_Object *o, int *cols, int *rows)\n" \
"{\n" \
" return edje_object_part_table_col_row_size_get(o, \"%s\", " \
"cols, rows);\n" \
"}\n\n"
#define H_CODEGEN_PART_TABLE_COL_ROW_SIZE_GET \
"Eina_Bool %s_%s_col_row_size_get(Evas_Object *o, int *cols, int *rows);\n"
#define C_CODEGEN_PART_EXTERNAL_PARAM_SET(type, param_type, field) \
"Eina_Bool\n" \
"%s_%s_%s_set(Evas_Object *o, "type"value)\n" \
"{\n" \
" Edje_External_Param param;\n\n" \
" param.name = \"%s\";\n" \
" param.type = "param_type";\n" \
" param."field" = value;\n" \
" return edje_object_part_external_param_set(o, \"%s\", &param);\n" \
"}\n\n"
#define H_CODEGEN_PART_EXTERNAL_PARAM_SET(type) \
"Eina_Bool %s_%s_%s_set(Evas_Object *o, "type"value);\n"
#define C_CODEGEN_PART_EXTERNAL_PARAM_GET(type, param_type, field) \
"Eina_Bool\n" \
"%s_%s_%s_get(Evas_Object *o, "type"*value)\n" \
"{\n" \
" if (!value) return EINA_FALSE;\n\n" \
" Edje_External_Param param;\n\n" \
" param.name = \"%s\";\n" \
" param.type = "param_type";\n" \
" if (!edje_object_part_external_param_get(o, \"%s\", &param))\n" \
" return EINA_FALSE;\n\n" \
" *value = param."field";\n" \
" return EINA_TRUE;\n" \
"}\n\n"
#define H_CODEGEN_PART_EXTERNAL_PARAM_GET(type) \
"Eina_Bool %s_%s_%s_get(Evas_Object *o, "type"*value);\n"
#define C_CODEGEN_PROGRAM_EMIT \
"void\n" \
"%s_%s_emit(Evas_Object *o)\n" \
"{\n" \
" edje_object_signal_emit(o, \"%s\", \"%s\");\n" \
"}\n\n"
#define H_CODEGEN_PROGRAM_EMIT \
"void %s_%s_emit(Evas_Object *o);\n"
#define C_CODEGEN_PROGRAM_CALLBACK_ADD \
"void\n" \
"%s_%s_callback_add(Evas_Object *o, Edje_Signal_Cb func, void *data)\n" \
"{\n" \
" edje_object_signal_callback_add(o, \"%s\", \"%s\", func, data);\n" \
"}\n\n"
#define H_CODEGEN_PROGRAM_CALLBACK_ADD \
"void %s_%s_callback_add(Evas_Object *o, Edje_Signal_Cb func, " \
"void *data);\n"
#define C_CODEGEN_PROGRAM_CALLBACK_DEL \
"void\n" \
"%s_%s_callback_del_full(Evas_Object *o, Edje_Signal_Cb func, void *data)\n" \
"{\n" \
" edje_object_signal_callback_del_full(o, \"%s\", \"%s\", func, data);\n" \
"}\n\n"
#define H_CODEGEN_PROGRAM_CALLBACK_DEL \
"void %s_%s_callback_del_full(Evas_Object *o, Edje_Signal_Cb func, " \
"void *data);\n"
typedef struct _Part_External_Info Part_External_Info;
struct _Part_External_Info {
const char *description, *name, *source;
char *apiname;
Eina_Bool draggable;
};
const Ecore_Getopt optdesc = {
"edje_codegen",
"%prog [options] <file.edj> <group> <source_file_name> <header_file_name>",
PACKAGE_VERSION,
"(C) 2012 - The Enlightenment Project",
"BSD",
"Edje generates the boilerplate code to get and set the "
"parts of a group from a compiled (binary) edje "
"file avoiding common errors with typos.\n",
0,
{
ECORE_GETOPT_STORE_STR('p', "prefix", "The prefix for the " \
"generataed code."),
ECORE_GETOPT_LICENSE('L', "license"),
ECORE_GETOPT_COPYRIGHT('C', "copyright"),
ECORE_GETOPT_VERSION('V', "version"),
ECORE_GETOPT_HELP('h', "help"),
ECORE_GETOPT_SENTINEL
}
};
static char *
_standardizes_header(const char *filename)
{
char *str, *itr, *aux;
aux = strrchr(filename, '/');
str = itr = strdup(aux ? aux + 1 : filename);
for (; *itr; itr++)
if (*itr == '.')
*itr = '_';
else
*itr = toupper(*itr);
return str;
}
static Eina_Bool
_open_file_descriptors(const char *source, const char *header)
{
header_fd = fopen(header, "w");
if (!header_fd)
return EINA_FALSE;
source_fd = fopen(source, "w");
if (!source_fd)
goto err;
return EINA_TRUE;
err:
fclose(header_fd);
return EINA_FALSE;
}
static Eina_Bool
_close_file_descriptors(void)
{
Eina_Bool ret = EINA_FALSE;
if (!fclose(header_fd))
ret = EINA_TRUE;
if (!fclose(source_fd))
ret &= EINA_TRUE;
return ret;
}
static Eina_Bool
_write_headers(const char *filename)
{
char buf[512];
char *str;
str = _standardizes_header(filename);
snprintf(buf, sizeof(buf), H_HEADER, str, str);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
{
free(str);
return EINA_FALSE;
}
free(str);
snprintf(buf, sizeof(buf), C_HEADER, filename);
if (fwrite(buf, strlen(buf), 1, source_fd) != 1)
return EINA_FALSE;
return EINA_TRUE;
}
static Eina_Bool
_write_footer(const char *filename)
{
char buf[512];
char *str;
str = _standardizes_header(filename);
snprintf(buf, sizeof(buf), H_FOOTER, str);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
{
free(str);
return EINA_FALSE;
}
free(str);
return EINA_TRUE;
}
static Eina_Bool
_write_object_get(void)
{
char buf[512];
snprintf(buf, sizeof(buf), H_CODEGEN_OBJECT_ADD, prefix);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
return EINA_FALSE;
snprintf(buf, sizeof(buf), C_CODEGEN_OBJECT_ADD, prefix, group, file, group);
if (fwrite(buf, strlen(buf), 1, source_fd) != 1)
return EINA_FALSE;
return EINA_TRUE;
}
static Eina_Bool
_write_part_draggable(const char *apiname, const char *partname)
{
char buf[1024];
#define TEMPLATE_DRAGGABLE(sufix, option) \
do { \
const char *template; \
template = C_CODEGEN_DRAG_##sufix(option); \
snprintf(buf, sizeof(buf), template, prefix, apiname, \
partname); \
if (fwrite(buf, strlen(buf), 1, source_fd) != 1) \
return EINA_FALSE; \
template = H_CODEGEN_DRAG_##sufix(option); \
snprintf(buf, sizeof(buf), template, prefix, \
apiname); \
if (fwrite(buf, strlen(buf), 1, header_fd) != 1) \
return EINA_FALSE; \
} while (0)
TEMPLATE_DRAGGABLE(SET, value);
TEMPLATE_DRAGGABLE(GET, value);
TEMPLATE_DRAGGABLE(SET, size);
TEMPLATE_DRAGGABLE(GET, size);
TEMPLATE_DRAGGABLE(SET, page);
TEMPLATE_DRAGGABLE(GET, page);
TEMPLATE_DRAGGABLE(SET, step);
TEMPLATE_DRAGGABLE(GET, step);
TEMPLATE_DRAGGABLE(ACTION, page);
TEMPLATE_DRAGGABLE(ACTION, step);
#undef TEMPLATE_DRAGGABLE
snprintf(buf, sizeof(buf), C_CODEGEN_DRAG_DIR_GET, prefix,
apiname, partname);
if (fwrite(buf, strlen(buf), 1, source_fd) != 1)
return EINA_FALSE;
snprintf(buf, sizeof(buf), H_CODEGEN_DRAG_DIR_GET, prefix, apiname);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
return EINA_FALSE;
return EINA_TRUE;
}
static Eina_Bool
_write_part_external_param(const Part_External_Info *info,
const Edje_External_Param_Info *param)
{
const char *template;
char buf[1024];
#define WRITE_TEMPLATE(type, param_type, field) \
do { \
template = C_CODEGEN_PART_EXTERNAL_PARAM_SET(type, param_type, field); \
snprintf(buf, sizeof(buf), template, info->apiname, info->name, \
param->name, param->name, info->name); \
if (fwrite(buf, strlen(buf), 1, source_fd) != 1) \
return EINA_FALSE; \
template = H_CODEGEN_PART_EXTERNAL_PARAM_SET(type); \
snprintf(buf, sizeof(buf), template, info->apiname, info->name, \
param->name); \
if (fwrite(buf, strlen(buf), 1, header_fd) != 1) \
return EINA_FALSE; \
template = \
C_CODEGEN_PART_EXTERNAL_PARAM_GET(type, param_type, field); \
snprintf(buf, sizeof(buf), template, info->apiname, info->name, \
param->name, param->name, info->name); \
if (fwrite(buf, strlen(buf), 1, source_fd) != 1) \
return EINA_FALSE; \
template = H_CODEGEN_PART_EXTERNAL_PARAM_GET(type); \
snprintf(buf, sizeof(buf), template, info->apiname, info->name, \
param->name); \
if (fwrite(buf, strlen(buf), 1, header_fd) != 1) \
return EINA_FALSE; \
} while (0)
switch (param->type)
{
case EDJE_EXTERNAL_PARAM_TYPE_INT:
WRITE_TEMPLATE("int ", "EDJE_EXTERNAL_PARAM_TYPE_INT", "i");
break;
case EDJE_EXTERNAL_PARAM_TYPE_DOUBLE:
WRITE_TEMPLATE("double ", "EDJE_EXTERNAL_PARAM_TYPE_DOUBLE", "d");
break;
case EDJE_EXTERNAL_PARAM_TYPE_STRING:
WRITE_TEMPLATE("const char *", "EDJE_EXTERNAL_PARAM_TYPE_STRING", "s");
break;
case EDJE_EXTERNAL_PARAM_TYPE_BOOL:
WRITE_TEMPLATE("Eina_Bool ", "EDJE_EXTERNAL_PARAM_TYPE_BOOL", "i");
break;
case EDJE_EXTERNAL_PARAM_TYPE_CHOICE:
WRITE_TEMPLATE("const char *", "EDJE_EXTERNAL_PARAM_TYPE_CHOICE", "s");
break;
default:
break;
}
#undef WRITE_TEMPLATE
return EINA_TRUE;
}
static Eina_Bool
_write_part_external(Eina_List **parts)
{
char buf[1024];
Eina_Iterator *itr;
Part_External_Info *ei;
const Eina_Hash_Tuple *tuple;
Eina_List *l, *l_next;
const char *name;
Eina_Bool ret = EINA_TRUE;
itr = edje_external_iterator_get();
EINA_ITERATOR_FOREACH(itr, tuple)
{
const Edje_External_Type *type = tuple->data;
const Edje_External_Param_Info *param;
name = tuple->key;
if (!type)
{
ERR("no type value for '%s'", name);
continue;
}
else if (type->abi_version != edje_external_type_abi_version_get())
{
ERR("type '%s' with incorrect abi_version %u (expected %u)",
name, type->abi_version, edje_external_type_abi_version_get());
continue;
}
EINA_LIST_FOREACH_SAFE(*parts, l, l_next, ei)
{
if (!strcmp(ei->source, name))
{
if (ei->description)
{
snprintf(buf, sizeof(buf), "\n/**\n * @brief %s\n */\n",
ei->description);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
{
ret = EINA_FALSE;
goto end;
}
}
if (ei->draggable)
{
if (!_write_part_draggable(ei->apiname, ei->name))
{
ret = EINA_FALSE;
goto end;
}
}
for (param = type->parameters_info; param->name != NULL;
param++)
if (!_write_part_external_param(ei, param))
{
ret = EINA_FALSE;
goto end;
}
edje_edit_string_free(ei->description);
free(ei->apiname);
free(ei);
*parts = eina_list_remove_list(*parts, l);
}
}
}
end:
if (eina_list_count(*parts) == 0) *parts = NULL;
eina_iterator_free(itr);
return ret;
}
static Eina_Bool
_write_part(const char *apiname, const char *partname, Edje_Part_Type parttype,
const char *description, Eina_Bool draggable)
{
char buf[512];
#define TEMPLATE_NAME(sufix) \
do { \
snprintf(buf, sizeof(buf), C_CODEGEN_##sufix, prefix, \
apiname, partname); \
if (fwrite(buf, strlen(buf), 1, source_fd) != 1) \
goto err; \
snprintf(buf, sizeof(buf), H_CODEGEN_##sufix, prefix, \
apiname); \
if (fwrite(buf, strlen(buf), 1, header_fd) != 1) \
goto err; \
} while (0)
if (description)
{
snprintf(buf, sizeof(buf), "\n/**\n * @brief %s\n */\n", description);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
goto err;
}
switch (parttype)
{
case EDJE_PART_TYPE_BOX:
TEMPLATE_NAME(PART_BOX_APPEND);
TEMPLATE_NAME(PART_BOX_PREPEND);
TEMPLATE_NAME(PART_BOX_INSERT_BEFORE);
TEMPLATE_NAME(PART_BOX_INSERT_AT);
TEMPLATE_NAME(PART_BOX_REMOVE);
TEMPLATE_NAME(PART_BOX_REMOVE_AT);
TEMPLATE_NAME(PART_BOX_REMOVE_ALL);
break;
case EDJE_PART_TYPE_TABLE:
TEMPLATE_NAME(PART_TABLE_PACK);
TEMPLATE_NAME(PART_TABLE_UNPACK);
TEMPLATE_NAME(PART_TABLE_CHILD_GET);
TEMPLATE_NAME(PART_TABLE_CLEAR);
TEMPLATE_NAME(PART_TABLE_COL_ROW_SIZE_GET);
break;
case EDJE_PART_TYPE_TEXT:
TEMPLATE_NAME(PART_TEXT_SET);
TEMPLATE_NAME(PART_TEXT_GET);
break;
case EDJE_PART_TYPE_SWALLOW:
TEMPLATE_NAME(PART_SWALLOW_SET);
TEMPLATE_NAME(PART_SWALLOW_GET);
break;
default:
break;
}
if (draggable)
if (!_write_part_draggable(apiname, partname))
goto err;
#undef TEMPLATE_NAME
return EINA_TRUE;
err:
ERR("Could not write the part: %s", partname);
return EINA_FALSE;
}
static inline Eina_Bool
_c_id_allowed(char c)
{
if ((c >= '0') && (c <= '9')) return EINA_TRUE;
if ((c >= 'a') && (c <= 'z')) return EINA_TRUE;
if ((c >= 'A') && (c <= 'Z')) return EINA_TRUE;
return EINA_FALSE;
}
static char *
_api_name_fix(const char *orig)
{
char *d, *d_end, buf[256];
const char *s;
if (!orig) return NULL;
s = orig;
d = buf;
d_end = d + sizeof(buf) - 1;
for (; (*s != '\0') && (d < d_end); s++, d++)
if (_c_id_allowed(*s)) *d = *s;
else *d = '_';
*d = '\0';
return strdup(buf);
}
static char *
_part_api_name_get(Evas_Object *ed, const char *program)
{
const char *orig;
char *fix;
orig = edje_edit_part_api_name_get(ed, program);
fix = _api_name_fix(orig);
edje_edit_string_free(orig);
return fix;
}
static Eina_Bool
_parse_parts(Evas_Object *ed)
{
Eina_List *parts, *l, *parts_external = NULL;
const char *name, *description;
char *apiname;
Edje_Part_Type type;
Eina_Bool draggable, ret = EINA_TRUE;
Part_External_Info *ei;
parts = edje_edit_parts_list_get(ed);
EINA_LIST_FOREACH(parts, l, name)
{
if (!(apiname = _part_api_name_get(ed, name)))
{
DBG("filter out part '%s': not API.", name);
continue;
}
type = edje_edit_part_type_get(ed, name);
if (!((type == EDJE_PART_TYPE_TEXT) ||
(type == EDJE_PART_TYPE_SWALLOW) ||
(type == EDJE_PART_TYPE_BOX) ||
(type == EDJE_PART_TYPE_EXTERNAL) ||
(type == EDJE_PART_TYPE_IMAGE) ||
(type == EDJE_PART_TYPE_TABLE)))
{
ERR("Invalid part type %d", type);
free(apiname);
continue;
}
if (edje_edit_part_drag_x_get(ed, name) ||
edje_edit_part_drag_y_get(ed, name))
draggable = EINA_TRUE;
else
draggable = EINA_FALSE;
description = edje_edit_part_api_description_get(ed, name);
if (type == EDJE_PART_TYPE_EXTERNAL)
{
ei = calloc(1, sizeof(Part_External_Info));
if (!ei) goto end;
ei->description = description;
ei->source = edje_edit_part_source_get(ed, name);
ei->apiname = apiname;
ei->name = name;
ei->draggable = draggable;
parts_external = eina_list_append(parts_external, ei);
}
else
{
if (!_write_part(apiname, name, type, description, draggable))
{
ret = EINA_FALSE;
edje_edit_string_free(description);
free(apiname);
goto end;
}
edje_edit_string_free(description);
free(apiname);
}
}
ret = _write_part_external(&parts_external);
end:
edje_edit_string_list_free(parts);
EINA_LIST_FREE(parts_external, ei)
{
edje_edit_string_free(ei->description);
free(ei->apiname);
free(ei);
}
return ret;
}
static Eina_Bool
_write_program_emit(const char *apiname, const char *source, const char *signal,
const char *description)
{
char buf[512];
snprintf(buf, sizeof(buf), C_CODEGEN_PROGRAM_EMIT, prefix,
apiname, signal, source);
if (fwrite(buf, strlen(buf), 1, source_fd) != 1)
goto err;
if (description)
{
snprintf(buf, sizeof(buf), "\n/**\n * @brief %s\n */\n", description);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
goto err;
}
snprintf(buf, sizeof(buf), H_CODEGEN_PROGRAM_EMIT, prefix,
apiname);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
goto err;
return EINA_TRUE;
err:
ERR("Could not write the program: %s", apiname);
return EINA_FALSE;
}
static Eina_Bool
_write_program_add(const char *apiname, const char *source, const char *signal,
const char *description)
{
char buf[512];
snprintf(buf, sizeof(buf), C_CODEGEN_PROGRAM_CALLBACK_ADD, prefix,
apiname, signal, source);
if (fwrite(buf, strlen(buf), 1, source_fd) != 1)
goto err;
snprintf(buf, sizeof(buf), C_CODEGEN_PROGRAM_CALLBACK_DEL, prefix,
apiname, signal, source);
if (fwrite(buf, strlen(buf), 1, source_fd) != 1)
goto err;
if (description)
{
snprintf(buf, sizeof(buf), "\n/**\n * @brief %s\n */\n", description);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
goto err;
}
snprintf(buf, sizeof(buf), H_CODEGEN_PROGRAM_CALLBACK_ADD, prefix,
apiname);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
goto err;
snprintf(buf, sizeof(buf), H_CODEGEN_PROGRAM_CALLBACK_DEL, prefix,
apiname);
if (fwrite(buf, strlen(buf), 1, header_fd) != 1)
goto err;
return EINA_TRUE;
err:
ERR("Could not write the program [action]: %s", apiname);
return EINA_FALSE;
}
static char *
_program_api_name_get(Evas_Object *ed, const char *program)
{
const char *orig;
char *fix;
orig = edje_edit_program_api_name_get(ed, program);
fix = _api_name_fix(orig);
edje_edit_string_free(orig);
return fix;
}
static Eina_Bool
_parse_programs(Evas_Object *ed)
{
Eina_Bool ret = EINA_TRUE;
Eina_List *programs, *l;
const char *name, *source = NULL, *signal = NULL, *description;
char *apiname;
Edje_Action_Type type;
programs = edje_edit_programs_list_get(ed);
EINA_LIST_FOREACH(programs, l, name)
{
if (!(apiname = _program_api_name_get(ed, name)))
{
DBG("filter out program '%s': not API.", name);
continue;
}
description = edje_edit_program_api_description_get(ed, name);
type = edje_edit_program_action_get(ed, name);
if (type == EDJE_ACTION_TYPE_SIGNAL_EMIT)
{
const char *str, *str2;
str = edje_edit_program_state_get(ed, name);
str2 = edje_edit_program_state2_get(ed, name);
if (!_write_program_add(apiname, str2, str, description))
{
ret = EINA_FALSE;
edje_edit_string_free(str);
edje_edit_string_free(str2);
break;
}
edje_edit_string_free(str);
edje_edit_string_free(str2);
}
signal = edje_edit_program_signal_get(ed, name);
if (!signal)
{
free(apiname);
edje_edit_string_free(description);
continue;
}
source = edje_edit_program_source_get(ed, name);
if (!source)
{
free(apiname);
edje_edit_string_free(signal);
edje_edit_string_free(description);
continue;
}
if (!_write_program_emit(apiname, source, signal, description))
{
ret = EINA_FALSE;
break;
}
edje_edit_string_free(description);
edje_edit_string_free(signal);
edje_edit_string_free(source);
free(apiname);
}
edje_edit_string_list_free(programs);
if (!ret)
{
edje_edit_string_free(description);
edje_edit_string_free(signal);
edje_edit_string_free(source);
free(apiname);
}
return ret;
}
static Eina_Bool
_module_matches(const char *module)
{
Eina_List *l;
const char *name;
EINA_LIST_FOREACH(externals, l, name)
{
if (!strcmp(module, name))
return EINA_TRUE;
}
return EINA_FALSE;
}
static Eina_Bool
_parse(void)
{
Evas_Object *ed;
Eina_Bool ret;
const char *module_name;
const Eina_List *modules_available, *l;
unsigned short modules_loaded = 0;
modules_available = edje_available_modules_get();
ed = edje_edit_object_add(ecore_evas_get(ee));
if (!edje_object_file_set(ed, file, group))
{
Edje_Load_Error err = edje_object_load_error_get(ed);
const char *errmsg = edje_load_error_str(err);
ERR("could not load group '%s' from file '%s': %s",
group, file, errmsg);
evas_object_del(ed);
return EINA_FALSE;
}
externals = edje_edit_externals_list_get(ed);
if (externals)
{
EINA_LIST_FOREACH(modules_available, l, module_name)
{
if (_module_matches(module_name))
{
if (!edje_module_load(module_name))
{
ERR("error loading external '%s'", module_name);
continue;
}
modules_loaded++;
}
}
}
if (eina_list_count(externals) != modules_loaded)
{
edje_edit_string_list_free(externals);
evas_object_del(ed);
return EINA_FALSE;
}
ret = _parse_parts(ed) && _parse_programs(ed);
evas_object_del(ed);
return ret;
}
int
main(int argc, char *argv[])
{
Eina_Bool quit_option = EINA_FALSE;
char *source, *header;
int arg_index, ret = 0;
Ecore_Getopt_Value values[] = {
ECORE_GETOPT_VALUE_STR(prefix),
ECORE_GETOPT_VALUE_BOOL(quit_option),
ECORE_GETOPT_VALUE_BOOL(quit_option),
ECORE_GETOPT_VALUE_BOOL(quit_option),
ECORE_GETOPT_VALUE_BOOL(quit_option),
ECORE_GETOPT_VALUE_NONE
};
setlocale(LC_NUMERIC, "C");
eina_init();
ecore_init();
ecore_evas_init();
edje_init();
if (argc < 2)
{
fprintf(stderr, "Missing action. See '--help or -h'.\n");
ret = 1;
goto error_log;
}
_log_dom = eina_log_domain_register("edje_codegen", EINA_COLOR_YELLOW);
if (_log_dom < 0)
{
EINA_LOG_CRIT("could not register log domain 'edje_codegen'");
ret = 1;
goto error_log;
}
arg_index = ecore_getopt_parse(&optdesc, values, argc, argv);
if (arg_index < 0)
{
ERR("could not parse arguments.");
ret = 1;
goto error_getopt;
}
else if (quit_option) goto error_getopt;
else if (arg_index != argc - 4)
{
fprintf(stderr, "Incorrect number of parameters. Requires " \
"fours arguments, an edje, the group, " \
"the source output (foo.c) and the header(foo.h).\n" \
"See %s --help\n", argv[0]);
ret = 1;
goto error_getopt;
}
file = argv[arg_index++];
// check if the file is accessible
if (access(file, R_OK) == -1)
{
ERR("File '%s' not accessible, error %d (%s).\n",
file, errno, strerror(errno));
ret = 1;
goto error_getopt;
}
group = argv[arg_index++];
source = argv[arg_index++];
header = argv[arg_index++];
if (!edje_file_group_exists(file, group))
{
ERR("The group %s not exists", group);
ret = 2;
goto error_getopt;
}
ee = ecore_evas_buffer_new(1, 1);
if (!ee)
{
ERR("could not create ecore_evas_buffer");
ret = 3;
goto error_getopt;
}
if (!_open_file_descriptors(source, header))
{
ERR("Could not create the source files, error %d (%s)",
errno, strerror(errno));
ret = 4;
goto error_getopt;
}
if (!_write_headers(header))
{
ERR("Could not write the header, error %d (%s)",
errno, strerror(errno));
ret = 5;
goto error_getopt;
}
if (!_write_object_get())
{
ERR("Could not write the object get, error %d (%s)",
errno, strerror(errno));
ret = 6;
goto error_getopt;
}
if (!_parse())
{
ERR("Could not parsing the EDJE");
ret = 7;
goto error_getopt;
}
if (!_write_footer(header))
{
ERR("Could not write the footer, error %d (%s)",
errno, strerror(errno));
ret = 8;
goto error_getopt;
}
if (!_close_file_descriptors())
{
ERR("Could not close the source files, error %d (%s)",
errno, strerror(errno));
ret = 9;
}
error_getopt:
if (ee)
ecore_evas_free(ee);
error_log:
edje_shutdown();
ecore_evas_shutdown();
ecore_shutdown();
eina_log_domain_unregister(_log_dom);
eina_shutdown();
if (ret > 4)
{
unlink(header);
unlink(source);
}
return ret;
}