forked from enlightenment/enventor
2298 lines
66 KiB
C
2298 lines
66 KiB
C
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <Enventor.h>
|
|
#include "enventor_private.h"
|
|
|
|
const char ATTR_PREPEND_COLON[] = ":";
|
|
const char ATTR_PREPEND_NONE[] = "";
|
|
const char ATTR_APPEND_SEMICOLON[] = ";";
|
|
const char ATTR_APPEND_TRANSITION_TIME[] = " 1.0;";
|
|
const char ATTR_APPEND_TRANSITION_TIME_FACTOR[] = " 1.0 0.0;";
|
|
const char ATTR_APPEND_TRANSITION_TIME_FACTOR2[] = " 1.0 0.0 0.0;";
|
|
const char ATTR_APPEND_TRANSITION_TIME_FACTOR4[] = " 1.0 0.0 0.0 0.0 0.0;";
|
|
|
|
typedef struct parser_attr_s
|
|
{
|
|
Eina_Stringshare *keyword;
|
|
const char *context;
|
|
attr_value value;
|
|
} parser_attr;
|
|
|
|
typedef struct cur_context_thread_data_s
|
|
{
|
|
Ecore_Thread *thread;
|
|
char *utf8;
|
|
int cur_pos;
|
|
const char *group_name;
|
|
const char *part_name;
|
|
const char *state_name;
|
|
double state_value;
|
|
void (*cb)(void *data, Eina_Stringshare *state_name, double state_value,
|
|
Eina_Stringshare *part_name, Eina_Stringshare *group_name);
|
|
void *cb_data;
|
|
parser_data *pd;
|
|
Eina_Bool collections: 1; //It contains collections?
|
|
} cur_context_td;
|
|
|
|
typedef struct type_init_thread_data_s
|
|
{
|
|
Eina_Inarray *attrs;
|
|
Ecore_Thread *thread;
|
|
parser_data *pd;
|
|
} type_init_td;
|
|
|
|
typedef struct bracket_thread_data_s
|
|
{
|
|
int pos;
|
|
char *text;
|
|
Bracket_Update_Cb update_cb;
|
|
void *data;
|
|
Ecore_Thread *thread;
|
|
int left;
|
|
int right;
|
|
parser_data *pd;
|
|
|
|
} bracket_td;
|
|
|
|
|
|
struct parser_s
|
|
{
|
|
Eina_Inarray *attrs;
|
|
cur_context_td *cntd;
|
|
type_init_td *titd;
|
|
bracket_td *btd;
|
|
};
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Internal method implementation */
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
cur_context_thread_blocking(void *data, Ecore_Thread *thread)
|
|
{
|
|
#define PART_SYNTAX_CNT 14
|
|
|
|
const char *GROUP = "group";
|
|
const int GROUP_LEN = 5;
|
|
const char *PARTS = "parts";
|
|
const int PARTS_LEN = 5;
|
|
const char *PART[PART_SYNTAX_CNT] = { "part", "image", "textblock",
|
|
"swallow", "rect", "group", "spacer", "proxy", "text", "gradient",
|
|
"box", "table", "external", "vector" };
|
|
const int PART_LEN[PART_SYNTAX_CNT] =
|
|
{ 4, 5, 9, 6, 4, 5, 6, 5, 4, 8, 3, 5, 8, 6};
|
|
|
|
const char *DESC[2] = { "desc", "description" };
|
|
const int DESC_LEN[2] = { 4, 11 };
|
|
const char *STATE = "state";
|
|
const char *DEF_STATE_NAME = "default";
|
|
const int DEF_STATE_LEN = 7;
|
|
|
|
cur_context_td *td = data;
|
|
char *utf8 = td->utf8;
|
|
int cur_pos = td->cur_pos;
|
|
char *p = utf8;
|
|
char *end = utf8 + cur_pos;
|
|
int i;
|
|
Eina_Bool inside_parts = EINA_FALSE;
|
|
Eina_Bool collections = td->collections;
|
|
|
|
int bracket = 0;
|
|
const char *group_name = NULL;
|
|
const char *part_name = NULL;
|
|
int group_name_len = 0;
|
|
int part_name_len = 0;
|
|
|
|
const char *desc_name = NULL;
|
|
int desc_name_len = 0;
|
|
const char *value = NULL;
|
|
int value_len = 0;
|
|
double value_convert = 0.0;
|
|
|
|
if (!collections) bracket = 1;
|
|
|
|
td->part_name = NULL;
|
|
td->group_name = NULL;
|
|
td->state_name = NULL;
|
|
|
|
while (p && p <= end)
|
|
{
|
|
if (ecore_thread_check(thread)) break;
|
|
|
|
//Skip "" range
|
|
if (!strncmp(p, QUOT_UTF8, QUOT_UTF8_LEN))
|
|
{
|
|
p += QUOT_UTF8_LEN;
|
|
p = strstr(p, QUOT_UTF8);
|
|
if (!p) return;
|
|
p += QUOT_UTF8_LEN;
|
|
continue;
|
|
}
|
|
|
|
//Enter one depth into Bracket.
|
|
if (*p == '{')
|
|
{
|
|
bracket++;
|
|
p++;
|
|
continue;
|
|
}
|
|
//Check inside comment
|
|
if (*p == '/')
|
|
{
|
|
if (p[1] == '/')
|
|
{
|
|
p = strchr(p, '\n');
|
|
continue;
|
|
}
|
|
else if (p[1] == '*')
|
|
{
|
|
p = strstr(p, "*/");
|
|
continue;
|
|
}
|
|
}
|
|
//Skip #if ~ #endif
|
|
if (!strncmp(p, "#if", 3))
|
|
{
|
|
p = strstr(p, "#endif");
|
|
if (!p) return;
|
|
p += 6; //strlen(#endif)
|
|
continue;
|
|
}
|
|
|
|
//Skip #define
|
|
if (!strncmp(p, "#define", 7))
|
|
{
|
|
//escape "\", "ie, #define .... \"
|
|
p += 7; //strlen(#define)
|
|
|
|
while (p <= end)
|
|
{
|
|
char *eol = strstr(p, "\n");
|
|
if (!eol) return;
|
|
|
|
char *slash = strstr(p, "\\");
|
|
|
|
p = eol + 1;
|
|
|
|
if (!slash || (eol < slash))
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
//Check whether outside of description or part or group
|
|
if ((*p == '}') && (p < end))
|
|
{
|
|
bracket--;
|
|
p++;
|
|
if (bracket == 1) group_name = NULL;
|
|
else if (bracket == 2 && inside_parts == EINA_TRUE)
|
|
inside_parts = EINA_FALSE;
|
|
else if (bracket == 3) part_name = NULL;
|
|
else if (bracket == 4) desc_name = NULL;
|
|
continue;
|
|
}
|
|
//check block "Parts" in
|
|
if (bracket == 2)
|
|
{
|
|
if (!strncmp(p, PARTS, PARTS_LEN))
|
|
{
|
|
inside_parts = EINA_TRUE;
|
|
p = strstr(p, "{");
|
|
if (!p) return;
|
|
continue;
|
|
}
|
|
}
|
|
//Check Part in
|
|
if (bracket == 3)
|
|
{
|
|
int part_idx = -1;
|
|
//part ? image ? swallow ? text ? rect ?
|
|
for (i = 0; i < PART_SYNTAX_CNT; i++)
|
|
{
|
|
if (!strncmp(p, PART[i], PART_LEN[i]))
|
|
{
|
|
part_idx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//we got a part!
|
|
if (part_idx != -1)
|
|
{
|
|
p += PART_LEN[part_idx];
|
|
char *name_begin = strstr(p, QUOT_UTF8);
|
|
if (!name_begin) return;
|
|
name_begin += QUOT_UTF8_LEN;
|
|
p = name_begin;
|
|
char *name_end = strstr(p, QUOT_UTF8);
|
|
if (!name_end) return;
|
|
part_name = name_begin;
|
|
part_name_len = name_end - name_begin;
|
|
p = name_end + QUOT_UTF8_LEN;
|
|
bracket++;
|
|
continue;
|
|
}
|
|
}
|
|
//Check Description in
|
|
if (bracket == 4)
|
|
{
|
|
//description? or desc?
|
|
int desc_idx = -1;
|
|
if (!strncmp(p, DESC[1], DESC_LEN[1])) desc_idx = 1;
|
|
else if (!strncmp(p, DESC[0], DESC_LEN[0])) desc_idx = 0;
|
|
|
|
//we got a description!
|
|
if (desc_idx != -1)
|
|
{
|
|
/* By default state will be */
|
|
desc_name = DEF_STATE_NAME;
|
|
/* recognized as "default" 0.0*/
|
|
desc_name_len = DEF_STATE_LEN;
|
|
value_convert = 0;
|
|
|
|
/* skip keyword */
|
|
p += DESC_LEN[desc_idx];
|
|
p = strstr(p, "{");
|
|
if (!p) return;
|
|
/*Limit size of text for processing*/
|
|
char *end_brace = strstr(p, "}");
|
|
if (!end_brace) return;
|
|
|
|
/* proccessing for "description" keyword with "state"
|
|
attribute */
|
|
if (desc_idx == 1)
|
|
{
|
|
char *state = strstr(p, STATE);
|
|
/* if name of state didn't find, */
|
|
if (!state || state > end_brace)
|
|
{
|
|
/* description will recognized as default 0.0*/
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
/*5 is strlen("state");*/
|
|
p += 5;
|
|
}
|
|
}
|
|
|
|
char *name_begin = strstr(p, QUOT_UTF8);
|
|
if (!name_begin)
|
|
continue;
|
|
char *end_range = strstr(p, ";");
|
|
if (!end_range) return;
|
|
|
|
/* if string placed outside desc block*/
|
|
if ((name_begin > end_brace) || (name_begin > end_range) ||
|
|
(end_range > end_brace))
|
|
continue;
|
|
|
|
/* Exception cases like: desc {image.normal: "img";} */
|
|
int alpha_present = 0;
|
|
char *string_itr;
|
|
for (string_itr = name_begin;
|
|
(string_itr > p) && (!alpha_present); string_itr--)
|
|
alpha_present = isalpha((int)*string_itr);
|
|
|
|
if (alpha_present && desc_idx == 0)
|
|
continue;
|
|
|
|
/*Extract state name and value */
|
|
name_begin += QUOT_UTF8_LEN;
|
|
p = name_begin;
|
|
char *name_end = strstr(p, QUOT_UTF8);
|
|
if (!name_end) return;
|
|
desc_name = name_begin;
|
|
desc_name_len = name_end - name_begin;
|
|
p = name_end + QUOT_UTF8_LEN;
|
|
value = p;
|
|
bracket++;
|
|
|
|
char *value_end = strchr(value, ';');
|
|
char *value_buf = NULL;
|
|
while (value < value_end)
|
|
{
|
|
if (isdigit(*value) || *value == '.')
|
|
{
|
|
value_len = value_end - value;
|
|
value_buf = (char *)calloc(1, value_len);
|
|
memcpy(value_buf, value, value_len);
|
|
break;
|
|
}
|
|
value++;
|
|
}
|
|
if (value_buf)
|
|
{
|
|
value_convert = atof(value_buf);
|
|
free(value_buf);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
//Check Group in. Probably inside of collections or the most outside.
|
|
if (bracket == 1)
|
|
{
|
|
if (!strncmp(p, GROUP, GROUP_LEN))
|
|
{
|
|
p += GROUP_LEN;
|
|
char *name_begin = strstr(p, QUOT_UTF8);
|
|
if (!name_begin) return;
|
|
name_begin += QUOT_UTF8_LEN;
|
|
p = name_begin;
|
|
char *name_end = strstr(p, QUOT_UTF8);
|
|
if (!name_end) return;
|
|
|
|
group_name = name_begin;
|
|
group_name_len = name_end - name_begin;
|
|
p = name_end + QUOT_UTF8_LEN;
|
|
bracket++;
|
|
continue;
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
if (part_name)
|
|
part_name = eina_stringshare_add_length(part_name, part_name_len);
|
|
if (desc_name)
|
|
desc_name = eina_stringshare_add_length(desc_name, desc_name_len);
|
|
if (group_name)
|
|
group_name = eina_stringshare_add_length(group_name, group_name_len);
|
|
|
|
td->part_name = part_name;
|
|
td->group_name = group_name;
|
|
td->state_name = desc_name;
|
|
td->state_value = value_convert;
|
|
}
|
|
|
|
Eina_Stringshare *
|
|
parser_cur_context_group_name_get(parser_data *pd EINA_UNUSED,
|
|
Evas_Object *entry, Eina_Bool collections)
|
|
{
|
|
const char *GROUP = "group";
|
|
const int GROUP_LEN = 5;
|
|
const char *markup = elm_entry_entry_get(entry);
|
|
char *utf8 = elm_entry_markup_to_utf8(markup);
|
|
char *p = utf8;
|
|
int cur_pos = elm_entry_cursor_pos_get(entry);
|
|
char *end = utf8 + cur_pos;
|
|
int bracket = 0;
|
|
const char *group_name = NULL;
|
|
int group_name_len = 0;
|
|
|
|
if (!collections) bracket = 1;
|
|
|
|
while (p && (p <= end))
|
|
{
|
|
//Skip "" range
|
|
if (!strncmp(p, QUOT_UTF8, QUOT_UTF8_LEN))
|
|
{
|
|
p += QUOT_UTF8_LEN;
|
|
p = strstr(p, QUOT_UTF8);
|
|
if (!p) goto end;
|
|
p += QUOT_UTF8_LEN;
|
|
continue;
|
|
}
|
|
//Enter one depth into Bracket.
|
|
if (*p == '{')
|
|
{
|
|
bracket++;
|
|
p++;
|
|
continue;
|
|
}
|
|
//Check inside comment
|
|
if (*p == '/')
|
|
{
|
|
if (p[1] == '/')
|
|
{
|
|
p = strchr(p, '\n');
|
|
continue;
|
|
}
|
|
else if (p[1] == '*')
|
|
{
|
|
p = strstr(p, "*/");
|
|
continue;
|
|
}
|
|
}
|
|
//Skip #if ~ #endif
|
|
if (!strncmp(p, "#if", 3))
|
|
{
|
|
p = strstr(p, "#endif");
|
|
if (!p) goto end;
|
|
p += 6; //strlen(#endif)
|
|
continue;
|
|
}
|
|
//Skip #define
|
|
if (!strncmp(p, "#define", 7))
|
|
{
|
|
//escape "\", "ie, #define .... \"
|
|
p += 7; //strlen(#define)
|
|
|
|
while (p <= end)
|
|
{
|
|
char *eol = strstr(p, "\n");
|
|
if (!eol) goto end;
|
|
|
|
char *slash = strstr(p, "\\");
|
|
|
|
p = eol + 1;
|
|
|
|
if (!slash || (eol < slash))
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
//Check whether outside of description or part or group
|
|
if ((*p == '}') && (p < end))
|
|
{
|
|
bracket--;
|
|
p++;
|
|
if (bracket == 1) group_name = NULL;
|
|
continue;
|
|
}
|
|
//Check Group in. Probably inside of collections or the most outside.
|
|
if (bracket == 1)
|
|
{
|
|
if (!strncmp(p, GROUP, GROUP_LEN))
|
|
{
|
|
p += GROUP_LEN;
|
|
char *name_begin = strstr(p, QUOT_UTF8);
|
|
if (!name_begin) goto end;
|
|
name_begin += QUOT_UTF8_LEN;
|
|
p = name_begin;
|
|
char *name_end = strstr(p, QUOT_UTF8);
|
|
if (!name_end) goto end;
|
|
|
|
group_name = name_begin;
|
|
group_name_len = name_end - name_begin;
|
|
p = name_end + QUOT_UTF8_LEN;
|
|
bracket++;
|
|
continue;
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
if (group_name)
|
|
group_name = eina_stringshare_add_length(group_name, group_name_len);
|
|
|
|
end:
|
|
free(utf8);
|
|
return group_name;
|
|
}
|
|
|
|
static void
|
|
cur_context_thread_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
|
|
{
|
|
cur_context_td *td = data;
|
|
if (td->pd) td->pd->cntd = NULL;
|
|
eina_stringshare_del(td->state_name);
|
|
eina_stringshare_del(td->part_name);
|
|
eina_stringshare_del(td->group_name);
|
|
free(td->utf8);
|
|
free(td);
|
|
}
|
|
|
|
static void
|
|
cur_context_thread_end(void *data, Ecore_Thread *thread)
|
|
{
|
|
cur_context_td *td = data;
|
|
td->cb(td->cb_data, td->state_name, td->state_value, td->part_name,
|
|
td->group_name);
|
|
cur_context_thread_cancel(data, thread);
|
|
}
|
|
|
|
|
|
static void
|
|
type_init_thread_blocking(void *data, Ecore_Thread *thread EINA_UNUSED)
|
|
{
|
|
type_init_td *td = data;
|
|
parser_attr attr;
|
|
td->attrs = eina_inarray_new(sizeof(parser_attr), 24);
|
|
eina_inarray_step_set(td->attrs, sizeof(Eina_Inarray), sizeof(parser_attr),
|
|
4);
|
|
|
|
//FIXME: construct from the configuration file.
|
|
|
|
|
|
//Context depended attributes
|
|
Eina_Array *wh = eina_array_new(2);
|
|
eina_array_push(wh, eina_stringshare_add("W:"));
|
|
eina_array_push(wh, eina_stringshare_add("H:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("min");
|
|
attr.value.strs = wh;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
attr.context = eina_stringshare_add("text");
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
wh = eina_array_new(2);
|
|
eina_array_push(wh, eina_stringshare_add("W:"));
|
|
eina_array_push(wh, eina_stringshare_add("H:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("max");
|
|
attr.value.strs = wh;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
attr.context = eina_stringshare_add("text");
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
// Context independed attributes
|
|
Eina_Array *trans = eina_array_new(11);
|
|
eina_array_push(trans, eina_stringshare_add("LINEAR"));
|
|
eina_array_push(trans, eina_stringshare_add("ACCELERATE"));
|
|
eina_array_push(trans, eina_stringshare_add("DECELERATE"));
|
|
eina_array_push(trans, eina_stringshare_add("SINUSOIDAL"));
|
|
eina_array_push(trans, eina_stringshare_add("ACCELERATE_FACTOR"));
|
|
eina_array_push(trans, eina_stringshare_add("DECELERATE_FACTOR"));
|
|
eina_array_push(trans, eina_stringshare_add("SINUSOIDAL_FACTOR"));
|
|
eina_array_push(trans, eina_stringshare_add("DIVISOR_INTERP"));
|
|
eina_array_push(trans, eina_stringshare_add("BOUNCE"));
|
|
eina_array_push(trans, eina_stringshare_add("SPRING"));
|
|
eina_array_push(trans, eina_stringshare_add("CUBIC_BEZIER"));
|
|
|
|
Eina_Array *trans_append_str = eina_array_new(11);
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME_FACTOR));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME_FACTOR));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME_FACTOR));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME_FACTOR2));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME_FACTOR2));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME_FACTOR2));
|
|
eina_array_push(trans_append_str, eina_stringshare_add(ATTR_APPEND_TRANSITION_TIME_FACTOR4));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("transition");
|
|
attr.value.strs = trans;
|
|
attr.value.type = ATTR_VALUE_CONSTANT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str_array = trans_append_str;
|
|
attr.value.use_append_str_array = EINA_TRUE;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *aspect_mode = eina_array_new(5);
|
|
eina_array_push(aspect_mode, eina_stringshare_add("NONE"));
|
|
eina_array_push(aspect_mode, eina_stringshare_add("NEITHER"));
|
|
eina_array_push(aspect_mode, eina_stringshare_add("VERTICAL"));
|
|
eina_array_push(aspect_mode, eina_stringshare_add("HORIZONTAL"));
|
|
eina_array_push(aspect_mode, eina_stringshare_add("BOTH"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("aspect_mode");
|
|
attr.value.strs = aspect_mode;
|
|
attr.value.type = ATTR_VALUE_CONSTANT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *aspect_prefer = eina_array_new(5);
|
|
eina_array_push(aspect_prefer, eina_stringshare_add("NONE"));
|
|
eina_array_push(aspect_prefer, eina_stringshare_add("VERTICAL"));
|
|
eina_array_push(aspect_prefer, eina_stringshare_add("HORIZONTAL"));
|
|
eina_array_push(aspect_prefer, eina_stringshare_add("BOTH"));
|
|
eina_array_push(aspect_prefer, eina_stringshare_add("SOURCE"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("aspect_preference");
|
|
attr.value.strs = aspect_prefer;
|
|
attr.value.type = ATTR_VALUE_CONSTANT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *effect = eina_array_new(11);
|
|
eina_array_push(effect, eina_stringshare_add("NONE"));
|
|
eina_array_push(effect, eina_stringshare_add("PLAIN"));
|
|
eina_array_push(effect, eina_stringshare_add("OUTLINE"));
|
|
eina_array_push(effect, eina_stringshare_add("SOFT_OUTLINE"));
|
|
eina_array_push(effect, eina_stringshare_add("SHADOW"));
|
|
eina_array_push(effect, eina_stringshare_add("SOFT_SHADOW"));
|
|
eina_array_push(effect, eina_stringshare_add("OUTLINE_SHADOW"));
|
|
eina_array_push(effect, eina_stringshare_add("OUTLINE_SOFT_SHADOW"));
|
|
eina_array_push(effect, eina_stringshare_add("FAR_SHADOW"));
|
|
eina_array_push(effect, eina_stringshare_add("FAR_SOFT_SHADOW"));
|
|
eina_array_push(effect, eina_stringshare_add("GLOW"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("effect");
|
|
attr.value.strs = effect;
|
|
attr.value.type = ATTR_VALUE_CONSTANT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *action = eina_array_new(22);
|
|
eina_array_push(action, eina_stringshare_add("STATE_SET"));
|
|
eina_array_push(action, eina_stringshare_add("ACTION_STOP"));
|
|
eina_array_push(action, eina_stringshare_add("SIGNAL_EMIT"));
|
|
eina_array_push(action, eina_stringshare_add("DRAG_VAL_SET"));
|
|
eina_array_push(action, eina_stringshare_add("DRAG_VAL_STEP"));
|
|
eina_array_push(action, eina_stringshare_add("DRAG_VAL_PAGE"));
|
|
eina_array_push(action, eina_stringshare_add("SCRIPT"));
|
|
eina_array_push(action, eina_stringshare_add("FOCUS_SET"));
|
|
eina_array_push(action, eina_stringshare_add("FOCUS_OBJECT"));
|
|
eina_array_push(action, eina_stringshare_add("PARAM_COPY"));
|
|
eina_array_push(action, eina_stringshare_add("PARAM_SET"));
|
|
eina_array_push(action, eina_stringshare_add("PLAY_SAMPLE"));
|
|
eina_array_push(action, eina_stringshare_add("PLAY_TONE"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_IMPULSE"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_TORQUE_IMPULSE"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_FORCE"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_TORQUE"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_FORCES_CLEAR"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_VEL_SET"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_ANG_VEL_SET"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_STOP"));
|
|
eina_array_push(action, eina_stringshare_add("PHYSICS_ROT_SET"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("action");
|
|
attr.value.strs = action;
|
|
attr.value.type = ATTR_VALUE_CONSTANT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *sig = eina_array_new(15);
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,down,*\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,down,1\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,down,2\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,down,3\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,up,*\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,up,1\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,up,2\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,up,3\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,clicked,*\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,clicked,1\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,clicked,2\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,clicked,3\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,move\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,in\""));
|
|
eina_array_push(sig, eina_stringshare_add("\"mouse,out\""));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("signal");
|
|
attr.value.strs = sig;
|
|
attr.value.type = ATTR_VALUE_CONSTANT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
//Type: Integer
|
|
Eina_Array *rgba = eina_array_new(4);
|
|
eina_array_push(rgba, eina_stringshare_add("R:"));
|
|
eina_array_push(rgba, eina_stringshare_add("G:"));
|
|
eina_array_push(rgba, eina_stringshare_add("B:"));
|
|
eina_array_push(rgba, eina_stringshare_add("A:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("color");
|
|
attr.value.strs = rgba;
|
|
attr.value.cnt = 4;
|
|
attr.value.min = 0;
|
|
attr.value.max = 255;
|
|
attr.value.type = ATTR_VALUE_INTEGER;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
rgba = eina_array_new(4);
|
|
eina_array_push(rgba, eina_stringshare_add("R:"));
|
|
eina_array_push(rgba, eina_stringshare_add("G:"));
|
|
eina_array_push(rgba, eina_stringshare_add("B:"));
|
|
eina_array_push(rgba, eina_stringshare_add("A:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("color2");
|
|
attr.value.strs = rgba;
|
|
attr.value.cnt = 4;
|
|
attr.value.min = 0;
|
|
attr.value.max = 255;
|
|
attr.value.type = ATTR_VALUE_INTEGER;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
rgba = eina_array_new(4);
|
|
eina_array_push(rgba, eina_stringshare_add("R:"));
|
|
eina_array_push(rgba, eina_stringshare_add("G:"));
|
|
eina_array_push(rgba, eina_stringshare_add("B:"));
|
|
eina_array_push(rgba, eina_stringshare_add("A:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("color3");
|
|
attr.value.strs = rgba;
|
|
attr.value.cnt = 4;
|
|
attr.value.min = 0;
|
|
attr.value.max = 255;
|
|
attr.value.type = ATTR_VALUE_INTEGER;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *scale = eina_array_new(1);
|
|
eina_array_push(scale, eina_stringshare_add("Scale:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("scale");
|
|
attr.value.strs = scale;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *smooth = eina_array_new(1);
|
|
eina_array_push(smooth, eina_stringshare_add("Smooth:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("smooth");
|
|
attr.value.strs = smooth;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *visible = eina_array_new(1);
|
|
eina_array_push(visible, eina_stringshare_add("Visibility:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("visible");
|
|
attr.value.strs = visible;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *onoff = eina_array_new(1);
|
|
eina_array_push(onoff, eina_stringshare_add("Map:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("on");
|
|
attr.value.strs = onoff;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *xy = eina_array_new(2);
|
|
eina_array_push(xy, eina_stringshare_add("X:"));
|
|
eina_array_push(xy, eina_stringshare_add("Y:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("fixed");
|
|
attr.value.strs = xy;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *size = eina_array_new(1);
|
|
eina_array_push(size, eina_stringshare_add("Size:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("size");
|
|
attr.value.strs = size;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 1;
|
|
attr.value.max = 255;
|
|
attr.value.type = ATTR_VALUE_INTEGER;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
wh = eina_array_new(2);
|
|
eina_array_push(wh, eina_stringshare_add("W:"));
|
|
eina_array_push(wh, eina_stringshare_add("H:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("min");
|
|
attr.value.strs = wh;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1000;
|
|
attr.value.type = ATTR_VALUE_INTEGER;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
wh = eina_array_new(2);
|
|
eina_array_push(wh, eina_stringshare_add("W:"));
|
|
eina_array_push(wh, eina_stringshare_add("H:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("max");
|
|
attr.value.strs = wh;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1000;
|
|
attr.value.type = ATTR_VALUE_INTEGER;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *mouse_events = eina_array_new(1);
|
|
eina_array_push(mouse_events, eina_stringshare_add("Mouse Events:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("mouse_events");
|
|
attr.value.strs = mouse_events;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_BOOLEAN;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
xy = eina_array_new(2);
|
|
eina_array_push(xy, eina_stringshare_add("X:"));
|
|
eina_array_push(xy, eina_stringshare_add("Y:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("offset");
|
|
attr.value.strs = xy;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = -100;
|
|
attr.value.max = 100;
|
|
attr.value.type = ATTR_VALUE_INTEGER;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
//Type: Float
|
|
xy = eina_array_new(2);
|
|
eina_array_push(xy, eina_stringshare_add("X:"));
|
|
eina_array_push(xy, eina_stringshare_add("Y:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("relative");
|
|
attr.value.strs = xy;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 1;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
wh = eina_array_new(2);
|
|
eina_array_push(wh, eina_stringshare_add("Min:"));
|
|
eina_array_push(wh, eina_stringshare_add("Max:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("aspect");
|
|
attr.value.strs = wh;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 1.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
xy = eina_array_new(2);
|
|
eina_array_push(xy, eina_stringshare_add("X:"));
|
|
eina_array_push(xy, eina_stringshare_add("Y:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("align");
|
|
attr.value.strs = xy;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 1.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *duration = eina_array_new(1);
|
|
eina_array_push(duration, eina_stringshare_add("Time:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("LINEAR");
|
|
attr.value.strs = duration;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 5.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
duration = eina_array_new(1);
|
|
eina_array_push(duration, eina_stringshare_add("Time:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("ACCELERATE");
|
|
attr.value.strs = duration;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 5.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
duration = eina_array_new(1);
|
|
eina_array_push(duration, eina_stringshare_add("Time:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("DECELERATE");
|
|
attr.value.strs = duration;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 5.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
duration = eina_array_new(1);
|
|
eina_array_push(duration, eina_stringshare_add("Time:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("SINUSOIDAL");
|
|
attr.value.strs = duration;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 5.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *duration_factor = eina_array_new(2);
|
|
eina_array_push(duration_factor, eina_stringshare_add("Time:"));
|
|
eina_array_push(duration_factor, eina_stringshare_add("Factor:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("ACCELERATE_FACTOR");
|
|
attr.value.strs = duration_factor;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 5.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
duration_factor = eina_array_new(2);
|
|
eina_array_push(duration_factor, eina_stringshare_add("Time:"));
|
|
eina_array_push(duration_factor, eina_stringshare_add("Factor:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("DECELERATE_FACTOR");
|
|
attr.value.strs = duration_factor;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 5.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
duration_factor = eina_array_new(2);
|
|
eina_array_push(duration_factor, eina_stringshare_add("Time:"));
|
|
eina_array_push(duration_factor, eina_stringshare_add("Factor:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("SINUSOIDAL_FACTOR");
|
|
attr.value.strs = duration_factor;
|
|
attr.value.cnt = 2;
|
|
attr.value.min = 0.0;
|
|
attr.value.max = 5.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
Eina_Array *base_scale = eina_array_new(1);
|
|
eina_array_push(base_scale, eina_stringshare_add("Scale:"));
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("base_scale");
|
|
attr.value.strs = base_scale;
|
|
attr.value.cnt = 1;
|
|
attr.value.min = 0.01;
|
|
attr.value.max = 10.0;
|
|
attr.value.type = ATTR_VALUE_FLOAT;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
//Type: Part
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("target");
|
|
attr.value.type = ATTR_VALUE_PART;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("to");
|
|
attr.value.type = ATTR_VALUE_PART;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("source");
|
|
attr.value.type = ATTR_VALUE_PART;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("to_x");
|
|
attr.value.type = ATTR_VALUE_PART;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("to_y");
|
|
attr.value.type = ATTR_VALUE_PART;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
//Type: State
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("STATE_SET");
|
|
attr.value.type = ATTR_VALUE_STATE;
|
|
attr.value.prepend_str = ATTR_PREPEND_NONE;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
attr.value.program = EINA_TRUE;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("inherit");
|
|
attr.value.type = ATTR_VALUE_STATE;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
//Type: Image
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("normal");
|
|
attr.value.type = ATTR_VALUE_IMAGE;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("tween");
|
|
attr.value.type = ATTR_VALUE_IMAGE;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
|
|
//Type: Program
|
|
memset(&attr, 0x00, sizeof(parser_attr));
|
|
attr.keyword = eina_stringshare_add("after");
|
|
attr.value.type = ATTR_VALUE_PROGRAM;
|
|
attr.value.prepend_str = ATTR_PREPEND_COLON;
|
|
attr.value.append_str = ATTR_APPEND_SEMICOLON;
|
|
eina_inarray_push(td->attrs, &attr);
|
|
}
|
|
|
|
static void
|
|
type_init_thread_end(void *data, Ecore_Thread *thread EINA_UNUSED)
|
|
{
|
|
type_init_td *td = data;
|
|
if (td->pd)
|
|
{
|
|
td->pd->titd = NULL;
|
|
td->pd->attrs = td->attrs;
|
|
}
|
|
free(td);
|
|
}
|
|
|
|
static void
|
|
type_init_thread_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
|
|
{
|
|
type_init_td *td = data;
|
|
if (td->pd) td->pd->titd = NULL;
|
|
free(td);
|
|
}
|
|
|
|
static const char *
|
|
end_of_parts_block_find(const char *pos)
|
|
{
|
|
//TODO: Process comments and quotes.
|
|
pos = strstr(pos, "parts");
|
|
if (!pos) return NULL;
|
|
pos = strstr(pos, "{");
|
|
if (!pos) return NULL;
|
|
pos++;
|
|
char level = 1;
|
|
|
|
while (*pos)
|
|
{
|
|
if (*pos == '{') level++;
|
|
else if (*pos == '}') level--;
|
|
|
|
if (!level) return --pos;
|
|
pos++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static const char *
|
|
group_beginning_pos_get(const char* source, const char *group_name)
|
|
{
|
|
if (!group_name) return NULL;
|
|
|
|
const char* GROUP_SYNTAX_NAME = "group";
|
|
const char *quot = QUOT_UTF8;
|
|
const int quot_len = QUOT_UTF8_LEN;
|
|
|
|
const char *pos = strstr(source, GROUP_SYNTAX_NAME);
|
|
int group_name_len = strlen(group_name);
|
|
|
|
//TODO: Process comments and quotes.
|
|
while (pos)
|
|
{
|
|
const char *name = strstr(pos, quot);
|
|
if (!name) return NULL;
|
|
name += quot_len;
|
|
pos = strstr(name, quot);
|
|
if (!pos) return NULL;
|
|
if (!strncmp(name, group_name, group_name_len))
|
|
return pos;
|
|
pos = strstr(++pos, GROUP_SYNTAX_NAME);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static Eina_Bool
|
|
parser_collections_block_pos_get(const Evas_Object *entry,
|
|
const char *block_name, int *ret)
|
|
{
|
|
if (!ret) return EINA_FALSE;
|
|
|
|
const char* GROUP_SYNTAX_NAME = "group";
|
|
const int BLOCK_NAME_LEN = strlen(block_name);
|
|
*ret = -1;
|
|
|
|
const char *text = elm_entry_entry_get(entry);
|
|
if (!text) return EINA_FALSE;
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
if (!utf8) return EINA_FALSE;
|
|
|
|
int cur_cursor = elm_entry_cursor_pos_get(entry);
|
|
const char *pos = utf8 + cur_cursor;
|
|
|
|
int len = strlen(utf8);
|
|
|
|
/*
|
|
* The next loop processing the text of block "group"
|
|
* from actual cursor postion up to the block name or
|
|
* the "group" position.
|
|
* Returned value for the cases when the position
|
|
* found correctly will be the first symbol of the next line.
|
|
*
|
|
* TODO and FIXME: possible wrong behaviour when before the
|
|
* "group" keyword will be found part with name like "blah.group".
|
|
*/
|
|
|
|
while (pos && (pos > utf8))
|
|
{
|
|
int block_pos = strncmp(block_name, pos, BLOCK_NAME_LEN);
|
|
if (block_pos == 0)
|
|
{
|
|
const char *block = pos + BLOCK_NAME_LEN;
|
|
while (block && (block < utf8 + len))
|
|
{
|
|
if (*block == '.')
|
|
{
|
|
block = strchr(block, '\n');
|
|
*ret = block - utf8 + 1;
|
|
free(utf8);
|
|
return EINA_FALSE;
|
|
}
|
|
else if (*block == '{')
|
|
{
|
|
block = strchr(block, '\n');
|
|
*ret = block - utf8 + 1;
|
|
free(utf8);
|
|
return EINA_TRUE;
|
|
}
|
|
block++;
|
|
}
|
|
free(utf8);
|
|
return EINA_FALSE;
|
|
}
|
|
int group_pos = strncmp(GROUP_SYNTAX_NAME, pos, 5);
|
|
if (group_pos == 0)
|
|
{
|
|
const char *group_block = pos + 5;
|
|
while (group_block && (group_block < utf8 + len))
|
|
{
|
|
if (*group_block == '{')
|
|
{
|
|
group_block = strchr(group_block, '\n');
|
|
*ret = group_block - utf8 + 1;
|
|
free(utf8);
|
|
return EINA_FALSE;
|
|
}
|
|
group_block++;
|
|
}
|
|
free(utf8);
|
|
return EINA_FALSE;
|
|
}
|
|
pos--;
|
|
}
|
|
free(utf8);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
static void
|
|
bracket_thread_blocking(void *data, Ecore_Thread *thread EINA_UNUSED)
|
|
{
|
|
bracket_td *btd = data;
|
|
int left_bracket = -1;
|
|
int right_bracket = -1;
|
|
int cur_pos = btd->pos;
|
|
int depth = 0;
|
|
const char *utf8 = btd->text;
|
|
|
|
if (cur_pos == 0) return;
|
|
|
|
int length = strlen(utf8);
|
|
|
|
// left, {
|
|
if (utf8[cur_pos] == '{')
|
|
{
|
|
left_bracket = cur_pos;
|
|
cur_pos++;
|
|
while (cur_pos < length)
|
|
{
|
|
if (utf8[cur_pos] == '{') depth++;
|
|
else if (utf8[cur_pos] == '}')
|
|
{
|
|
if (depth) depth--;
|
|
else
|
|
{
|
|
right_bracket = cur_pos;
|
|
break;
|
|
}
|
|
}
|
|
cur_pos++;
|
|
}
|
|
}
|
|
// left, }
|
|
else if(utf8[cur_pos] == '}')
|
|
{
|
|
right_bracket = cur_pos;
|
|
cur_pos--;
|
|
while (cur_pos)
|
|
{
|
|
if (utf8[cur_pos] == '}') depth++;
|
|
else if(utf8[cur_pos] == '{')
|
|
{
|
|
if(depth) depth--;
|
|
else
|
|
{
|
|
left_bracket = cur_pos;
|
|
break;
|
|
}
|
|
}
|
|
cur_pos--;
|
|
}
|
|
}
|
|
// right, {
|
|
else if(utf8[cur_pos - 1] == '{')
|
|
{
|
|
left_bracket = cur_pos - 1;
|
|
while (cur_pos < length)
|
|
{
|
|
if (utf8[cur_pos] == '{') depth++;
|
|
else if (utf8[cur_pos] == '}')
|
|
{
|
|
if (depth) depth--;
|
|
else
|
|
{
|
|
right_bracket = cur_pos;
|
|
break;
|
|
}
|
|
}
|
|
cur_pos++;
|
|
}
|
|
}
|
|
// right, }
|
|
else if(utf8[cur_pos - 1] == '}')
|
|
{
|
|
right_bracket = cur_pos - 1;
|
|
cur_pos -= 2;
|
|
while (cur_pos)
|
|
{
|
|
if (utf8[cur_pos] == '}') depth++;
|
|
else if (utf8[cur_pos] == '{')
|
|
{
|
|
if(depth) depth--;
|
|
else
|
|
{
|
|
left_bracket = cur_pos;
|
|
break;
|
|
}
|
|
}
|
|
cur_pos--;
|
|
}
|
|
}
|
|
|
|
if (left_bracket == -1 || right_bracket == -1)
|
|
{
|
|
left_bracket = -1;
|
|
right_bracket = -1;
|
|
}
|
|
|
|
btd->left = left_bracket;
|
|
btd->right = right_bracket;
|
|
}
|
|
|
|
static void
|
|
bracket_thread_cancel(void *data, Ecore_Thread *thread EINA_UNUSED)
|
|
{
|
|
bracket_td *btd = data;
|
|
if (btd->pd) btd->pd->btd = NULL;
|
|
free(btd->text);
|
|
free(btd);
|
|
}
|
|
|
|
static void
|
|
bracket_thread_end(void *data, Ecore_Thread *thread)
|
|
{
|
|
bracket_td *btd = data;
|
|
btd->update_cb(btd->data, btd->left, btd->right);
|
|
bracket_thread_cancel(data, thread);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Externally accessible calls */
|
|
/*****************************************************************************/
|
|
|
|
void
|
|
parser_cancel(parser_data *pd)
|
|
{
|
|
if (pd->cntd)
|
|
{
|
|
pd->cntd->pd = NULL;
|
|
ecore_thread_cancel(pd->cntd->thread);
|
|
}
|
|
}
|
|
|
|
char *
|
|
parser_name_get(parser_data *pd EINA_UNUSED, const char *cur)
|
|
{
|
|
if (!cur) return NULL;
|
|
|
|
char *p = (char *) cur;
|
|
char *end;
|
|
p = strstr(p, "\"");
|
|
if (!p) return NULL;
|
|
p++;
|
|
end = strstr(p, "\"");
|
|
if (!end) return NULL;
|
|
|
|
//Don't find if the name is in the next lines.
|
|
char *eol = strstr(cur, "\n");
|
|
if (eol && (eol < p)) return NULL;
|
|
|
|
return eina_strndup(p, (end - p));
|
|
}
|
|
|
|
attr_value *
|
|
parser_attribute_get(parser_data *pd, const char *text, const char *cur,
|
|
const char *selected)
|
|
{
|
|
if (!text || !cur) return NULL;
|
|
if ((*cur == ';') || (*cur == ':')) return NULL;
|
|
|
|
parser_attr *attr;
|
|
Eina_Bool instring = EINA_FALSE;
|
|
|
|
char *p = (char *) cur;
|
|
|
|
while (p >= text)
|
|
{
|
|
if (*p == '\"') instring = !instring;
|
|
p--;
|
|
}
|
|
if (instring) return NULL;
|
|
|
|
int name_count;
|
|
const char **cur_context = autocomp_current_context_get(&name_count);
|
|
int i;
|
|
|
|
EINA_INARRAY_FOREACH(pd->attrs, attr)
|
|
{
|
|
if (strcmp(selected, attr->keyword)) continue;
|
|
if (!attr->context) return &attr->value;
|
|
if (!cur_context) continue;
|
|
for (i = 0; i < name_count; i++)
|
|
{
|
|
if (!strcmp(cur_context[i], attr->context))
|
|
return &attr->value;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Function is_numberic is refer to the following url.
|
|
http://rosettacode.org/wiki/Determine_if_a_string_is_numeric#C */
|
|
static Eina_Bool
|
|
is_numberic(const char *str)
|
|
{
|
|
Eina_Bool ret = EINA_FALSE;
|
|
char *p;
|
|
|
|
if (!str || (*str == '\0') || isspace(*str))
|
|
return EINA_FALSE;
|
|
|
|
double v EINA_UNUSED = strtod(str, &p);
|
|
|
|
if (*p == '\0') ret = EINA_TRUE;
|
|
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
parser_attribute_value_set(attr_value *value, char *cur)
|
|
{
|
|
const char token[4] = " ;:";
|
|
char *str = strtok(cur, token);
|
|
int i;
|
|
|
|
if (!str) return;
|
|
str = strtok(NULL, token); //Skip the keyword
|
|
|
|
//Initialize attribute values
|
|
for (i = 0; i < value->cnt; i++)
|
|
value->val[i] = 0;
|
|
|
|
for (i = 0; str && (i < value->cnt); str = strtok(NULL, token))
|
|
{
|
|
if (!is_numberic(str)) continue;
|
|
|
|
value->val[i] = atof(str);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
Eina_Stringshare *
|
|
parser_paragh_name_get(parser_data *pd EINA_UNUSED, Evas_Object *entry)
|
|
{
|
|
//FIXME: list up groups
|
|
#define GROUP_CNT 20
|
|
typedef struct _group_info
|
|
{
|
|
char *str;
|
|
int len;
|
|
} group_info;
|
|
|
|
group_info group_list[GROUP_CNT] =
|
|
{
|
|
{ "collections", 11 },
|
|
{ "description", 11 },
|
|
{ "desc", 4 },
|
|
{ "fill", 4 },
|
|
{ "group", 5 },
|
|
{ "images", 6 },
|
|
{ "image", 5 },
|
|
{ "map", 3 },
|
|
{ "origin", 6 },
|
|
{ "parts", 5 },
|
|
{ "part", 4 },
|
|
{ "programs", 8 },
|
|
{ "program", 7 },
|
|
{ "rect", 4 },
|
|
{ "rel1", 4 },
|
|
{ "rel2", 4 },
|
|
{ "spacer", 6 },
|
|
{ "swallow", 7 },
|
|
{ "textblock", 9 },
|
|
{ "text", 4 }
|
|
};
|
|
|
|
const char *text = elm_entry_entry_get(entry);
|
|
if (!text) return NULL;
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
if (!utf8) return NULL;
|
|
|
|
int cur_pos = elm_entry_cursor_pos_get(entry);
|
|
if (cur_pos < 1) return NULL;
|
|
|
|
const char *quot = QUOT_UTF8;
|
|
int quot_len = QUOT_UTF8_LEN;
|
|
char *cur = utf8;
|
|
char *end = cur + cur_pos;
|
|
char *stack[20];
|
|
int depth = 0;
|
|
|
|
//1. Figure out depth.
|
|
while (cur <= end)
|
|
{
|
|
//Skip "" range
|
|
if (!strncmp(cur, quot, quot_len))
|
|
{
|
|
cur += quot_len;
|
|
cur = strstr(cur, quot);
|
|
if (!cur)
|
|
{
|
|
free(utf8);
|
|
return NULL;
|
|
}
|
|
cur += quot_len;
|
|
}
|
|
|
|
if (*cur == '{')
|
|
{
|
|
stack[depth] = cur;
|
|
depth++;
|
|
}
|
|
else if (*cur == '}')
|
|
{
|
|
if (depth > 0) depth--;
|
|
}
|
|
cur++;
|
|
}
|
|
|
|
if (depth == 0)
|
|
{
|
|
free(utf8);
|
|
return NULL;
|
|
}
|
|
|
|
//2. Parse the paragraph Name
|
|
cur = stack[depth - 1];
|
|
int i;
|
|
while (cur > utf8)
|
|
{
|
|
cur--;
|
|
for (i = 0; i < GROUP_CNT; i++)
|
|
{
|
|
group_info *gi = &group_list[i];
|
|
if (!strncmp(cur, gi->str, gi->len))
|
|
{
|
|
free(utf8);
|
|
return eina_stringshare_add_length(gi->str, gi->len);
|
|
}
|
|
}
|
|
}
|
|
|
|
free(utf8);
|
|
return NULL;
|
|
}
|
|
|
|
Eina_Stringshare*
|
|
parser_cur_context_fast_get(Evas_Object *entry, const char *scope)
|
|
{
|
|
const char *quot = QUOT_UTF8;
|
|
const int quot_len = QUOT_UTF8_LEN;
|
|
const int scope_len = strlen(scope);
|
|
|
|
const char *text = elm_entry_entry_get(entry);
|
|
if (!text) return NULL;
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
if (!utf8) return NULL;
|
|
|
|
int cur_pos = elm_entry_cursor_pos_get(entry);
|
|
|
|
char *p = utf8;
|
|
char *end = utf8 + cur_pos;
|
|
|
|
int bracket = 0;
|
|
const char *name = NULL;
|
|
int name_len = 0;
|
|
|
|
while (p <= end)
|
|
{
|
|
//Skip "" range
|
|
if (!strncmp(p, quot, quot_len))
|
|
{
|
|
p += quot_len;
|
|
p = strstr(p, quot);
|
|
if (!p) goto end;
|
|
p += quot_len;
|
|
continue;
|
|
}
|
|
|
|
if (*p == '{')
|
|
{
|
|
bracket++;
|
|
p++;
|
|
continue;
|
|
}
|
|
|
|
//Check whether outside of scope
|
|
if ((*p == '}') && (p < end))
|
|
{
|
|
bracket--;
|
|
p++;
|
|
|
|
if (bracket == 1) name = NULL;
|
|
continue;
|
|
}
|
|
//Check Scope in
|
|
if (!strncmp(p, scope, scope_len))
|
|
{
|
|
p += scope_len;
|
|
char *name_begin = strstr(p, quot);
|
|
if (!name_begin) goto end;
|
|
name_begin += quot_len;
|
|
p = name_begin;
|
|
char *name_end = strstr(p, quot);
|
|
if (!name_end) goto end;
|
|
name = name_begin;
|
|
name_len = name_end - name_begin;
|
|
p = name_end + quot_len;
|
|
bracket++;
|
|
continue;
|
|
}
|
|
p++;
|
|
}
|
|
if (name) name = eina_stringshare_add_length(name, name_len);
|
|
|
|
end:
|
|
free(utf8);
|
|
return name;
|
|
}
|
|
|
|
void
|
|
parser_cur_context_get(parser_data *pd, Evas_Object *entry,
|
|
void (*cb)(void *data, Eina_Stringshare *state_name,
|
|
double state_value, Eina_Stringshare *part_name,
|
|
Eina_Stringshare *group_name), void *data,
|
|
Eina_Bool collections)
|
|
{
|
|
if (pd->cntd)
|
|
{
|
|
pd->cntd->pd = NULL;
|
|
ecore_thread_cancel(pd->cntd->thread);
|
|
}
|
|
|
|
const char *text = elm_entry_entry_get(entry);
|
|
if (!text) return;
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
if (!utf8) return;
|
|
|
|
cur_context_td *td = calloc(1, sizeof(cur_context_td));
|
|
if (!td)
|
|
{
|
|
free(utf8);
|
|
EINA_LOG_ERR("Failed to allocate Memory!");
|
|
return;
|
|
}
|
|
|
|
td->pd = pd;
|
|
pd->cntd = td;
|
|
td->utf8 = utf8;
|
|
td->cur_pos = elm_entry_cursor_pos_get(entry);
|
|
td->cb = cb;
|
|
td->cb_data = data;
|
|
td->collections = collections;
|
|
|
|
td->thread = ecore_thread_run(cur_context_thread_blocking,
|
|
cur_context_thread_end,
|
|
cur_context_thread_cancel,
|
|
td);
|
|
}
|
|
|
|
int
|
|
parser_line_cnt_get(parser_data *pd EINA_UNUSED, const char *src)
|
|
{
|
|
if (!src) return 0;
|
|
|
|
int cnt = 0;
|
|
|
|
while ((src = strstr(src, EOL)))
|
|
{
|
|
cnt++;
|
|
src += EOL_LEN;
|
|
}
|
|
|
|
return cnt;
|
|
}
|
|
|
|
Eina_Stringshare *
|
|
parser_first_group_name_get(parser_data *pd EINA_UNUSED, Evas_Object *entry)
|
|
{
|
|
const char *markup = elm_entry_entry_get(entry);
|
|
char *utf8 = elm_entry_markup_to_utf8(markup);
|
|
int utf8_len = strlen(utf8);
|
|
char *p = utf8;
|
|
|
|
const char *quot = QUOT_UTF8;
|
|
const char *group = "group";
|
|
const int quot_len = QUOT_UTF8_LEN;
|
|
const int group_len = 5; //strlen("group");
|
|
const char *group_name = NULL;
|
|
|
|
while (p < (utf8 + utf8_len))
|
|
{
|
|
//Skip "" range
|
|
if (!strncmp(p, quot, quot_len))
|
|
{
|
|
p += quot_len;
|
|
p = strstr(p, quot);
|
|
if (!p) goto end;
|
|
p += quot_len;
|
|
continue;
|
|
}
|
|
|
|
//Skip comments: /* ~ */
|
|
if ((*p == '/') && (*(++p) == '*'))
|
|
{
|
|
p = strstr(p, "*/");
|
|
if (!p) goto end;
|
|
p += 2;
|
|
continue;
|
|
}
|
|
|
|
//Skip comments: //
|
|
if ((*p == '/') && (*(++p) == '/'))
|
|
{
|
|
p = strstr(p, "\n");
|
|
if (!p) goto end;
|
|
p++;
|
|
continue;
|
|
}
|
|
|
|
//Skip #if ~ #endif
|
|
if (!strncmp(p, "#if", 3))
|
|
{
|
|
p = strstr(p, "#endif");
|
|
if (!p) goto end;
|
|
p += 6; //strlen(#endif)
|
|
continue;
|
|
}
|
|
|
|
//Skip #define
|
|
if (!strncmp(p, "#define", 7))
|
|
{
|
|
//escape "\", "ie, #define .... \"
|
|
p += 7; //strlen(#define)
|
|
|
|
while (p < (utf8 + utf8_len))
|
|
{
|
|
char *eol = strstr(p, "\n");
|
|
if (!eol) goto end;
|
|
|
|
char *slash = strstr(p, "\\");
|
|
|
|
p = eol + 1;
|
|
|
|
if (!slash || (eol < slash))
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
//group?
|
|
if (!strncmp(p, group, group_len))
|
|
{
|
|
p += group_len;
|
|
char *name_begin = strstr(p, quot);
|
|
if (!name_begin) goto end;
|
|
name_begin += quot_len;
|
|
p = name_begin;
|
|
char *name_end = strstr(p, quot);
|
|
if (!name_end) goto end;
|
|
|
|
group_name = eina_stringshare_add_length(name_begin,
|
|
(name_end - name_begin));
|
|
goto end;
|
|
}
|
|
p++;
|
|
}
|
|
|
|
end:
|
|
free(utf8);
|
|
|
|
return group_name;
|
|
}
|
|
|
|
Eina_List *
|
|
parser_states_filtered_name_get(Eina_List *states)
|
|
{
|
|
Eina_List *ret = NULL;
|
|
Eina_List *l;
|
|
char *state;
|
|
EINA_LIST_FOREACH(states, l, state)
|
|
{
|
|
char *p = state;
|
|
char *pp = state;
|
|
while ((p = strstr(p, " ")))
|
|
{
|
|
pp = p;
|
|
p++;
|
|
}
|
|
ret = eina_list_append(ret, eina_strndup(state, pp - state));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
parser_data *
|
|
parser_init(void)
|
|
{
|
|
parser_data *pd = calloc(1, sizeof(parser_data));
|
|
if (!pd)
|
|
{
|
|
EINA_LOG_ERR("Failed to allocate Memory!");
|
|
return NULL;
|
|
}
|
|
|
|
type_init_td *td = calloc(1, sizeof(type_init_td));
|
|
if (!td)
|
|
{
|
|
EINA_LOG_ERR("Failed to allocate Memory!");
|
|
free(pd);
|
|
return NULL;
|
|
}
|
|
|
|
td->pd = pd;
|
|
pd->titd = td;
|
|
td->thread = ecore_thread_run(type_init_thread_blocking,
|
|
type_init_thread_end,
|
|
type_init_thread_cancel, td);
|
|
return pd;
|
|
}
|
|
|
|
void
|
|
parser_term(parser_data *pd)
|
|
{
|
|
if (pd->cntd)
|
|
{
|
|
ecore_thread_cancel(pd->cntd->thread);
|
|
pd->cntd->pd = NULL;
|
|
}
|
|
if (pd->titd)
|
|
{
|
|
ecore_thread_cancel(pd->titd->thread);
|
|
pd->titd->pd = NULL;
|
|
}
|
|
if (pd->btd)
|
|
{
|
|
ecore_thread_cancel(pd->btd->thread);
|
|
pd->btd->pd = NULL;
|
|
}
|
|
|
|
if (pd->attrs)
|
|
{
|
|
parser_attr *attr;
|
|
EINA_INARRAY_FOREACH(pd->attrs, attr)
|
|
{
|
|
eina_stringshare_del(attr->keyword);
|
|
|
|
if (attr->value.strs)
|
|
{
|
|
while (eina_array_count(attr->value.strs))
|
|
eina_stringshare_del(eina_array_pop(attr->value.strs));
|
|
eina_array_free(attr->value.strs);
|
|
}
|
|
}
|
|
eina_inarray_free(pd->attrs);
|
|
}
|
|
|
|
free(pd);
|
|
}
|
|
|
|
int
|
|
parser_end_of_parts_block_pos_get(const Evas_Object *entry,
|
|
const char *group_name)
|
|
{
|
|
if (!group_name) return -1;
|
|
|
|
const char *text = elm_entry_entry_get(entry);
|
|
if (!text) return -1;
|
|
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
if (!utf8) return -1;
|
|
|
|
const char *pos = group_beginning_pos_get(utf8, group_name);
|
|
if (!pos)
|
|
{
|
|
free(utf8);
|
|
return -1;
|
|
}
|
|
|
|
pos = end_of_parts_block_find(++pos);
|
|
if (!pos)
|
|
{
|
|
free(utf8);
|
|
return - 1;
|
|
}
|
|
|
|
int ret = (pos - utf8) + 1;
|
|
|
|
free(utf8);
|
|
|
|
return ret;
|
|
}
|
|
|
|
Eina_Bool
|
|
parser_images_pos_get(const Evas_Object *entry, int *ret)
|
|
{
|
|
return parser_collections_block_pos_get(entry, "images", ret);
|
|
}
|
|
|
|
Eina_Bool
|
|
parser_styles_pos_get(const Evas_Object *entry, int *ret)
|
|
{
|
|
return parser_collections_block_pos_get(entry, "styles", ret);
|
|
}
|
|
|
|
Eina_Bool
|
|
parser_is_image_name(const Evas_Object *entry, const char *str)
|
|
{
|
|
int start_pos, end_pos = -1, i;
|
|
if (!parser_collections_block_pos_get(entry, "images", &start_pos))
|
|
return EINA_FALSE;
|
|
|
|
const char *text = elm_entry_entry_get(entry);
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
int utf8_len = strlen(utf8);
|
|
|
|
for (i = start_pos ; i < utf8_len; i++)
|
|
if (utf8[i] == '}')
|
|
{
|
|
end_pos = i;
|
|
break;
|
|
}
|
|
|
|
if (end_pos < 0) return EINA_FALSE;
|
|
|
|
char *candidate_str = alloca(end_pos - start_pos + 1);
|
|
const char *src_str = elm_entry_markup_to_utf8(str);
|
|
strncpy(candidate_str, utf8 + start_pos, end_pos - start_pos);
|
|
candidate_str[end_pos - start_pos] = '\0';
|
|
|
|
if (strstr(candidate_str, src_str))
|
|
return EINA_TRUE;
|
|
else
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
void
|
|
parser_bracket_cancel(parser_data *pd)
|
|
{
|
|
if (pd->btd)
|
|
{
|
|
ecore_thread_cancel(pd->btd->thread);
|
|
pd->btd->pd = NULL;
|
|
pd->btd = NULL;
|
|
}
|
|
}
|
|
|
|
void
|
|
parser_bracket_find(parser_data *pd, Evas_Object *entry,
|
|
Bracket_Update_Cb func, void *data)
|
|
{
|
|
if (pd->btd)
|
|
{
|
|
pd->btd->pd = NULL;
|
|
ecore_thread_cancel(pd->btd->thread);
|
|
}
|
|
|
|
const char *text = elm_entry_entry_get(entry);
|
|
char *utf8 = elm_entry_markup_to_utf8(text);
|
|
int pos = elm_entry_cursor_pos_get(entry);
|
|
|
|
bracket_td *btd = malloc(sizeof(bracket_td));
|
|
pd->btd = btd;
|
|
|
|
btd->pos = pos;
|
|
btd->text = utf8;
|
|
btd->update_cb = func;
|
|
btd->data = data;
|
|
btd->pd = pd;
|
|
btd->thread = ecore_thread_run(bracket_thread_blocking,
|
|
bracket_thread_end,
|
|
bracket_thread_cancel,
|
|
btd);
|
|
}
|
|
|
|
Eina_List *
|
|
parser_group_list_get(parser_data *pd EINA_UNUSED, Evas_Object *entry)
|
|
{
|
|
const char *markup = elm_entry_entry_get(entry);
|
|
char *utf8 = elm_entry_markup_to_utf8(markup);
|
|
int utf8_len = strlen(utf8);
|
|
char *p = utf8;
|
|
|
|
const char *quot = QUOT_UTF8;
|
|
const char *group = "group";
|
|
const int quot_len = QUOT_UTF8_LEN;
|
|
const int group_len = 5; //strlen("group");
|
|
const char *group_name = NULL;
|
|
Eina_List *group_list = NULL;
|
|
|
|
while (p < (utf8 + utf8_len))
|
|
{
|
|
//Skip "" range
|
|
if (!strncmp(p, quot, quot_len))
|
|
{
|
|
p += quot_len;
|
|
p = strstr(p, quot);
|
|
if (!p) goto end;
|
|
p += quot_len;
|
|
continue;
|
|
}
|
|
|
|
//Skip comments: /* ~ */
|
|
if ((*p == '/') && (*(++p) == '*'))
|
|
{
|
|
p = strstr(p, "*/");
|
|
if (!p) goto end;
|
|
p += 2;
|
|
continue;
|
|
}
|
|
|
|
//Skip comments: //
|
|
if ((*p == '/') && (*(++p) == '/'))
|
|
{
|
|
p = strstr(p, "\n");
|
|
if (!p) goto end;
|
|
p++;
|
|
continue;
|
|
}
|
|
|
|
//Skip #if ~ #endif
|
|
if (!strncmp(p, "#if", 3))
|
|
{
|
|
p = strstr(p, "#endif");
|
|
if (!p) goto end;
|
|
p += 6; //strlen(#endif)
|
|
continue;
|
|
}
|
|
|
|
//Skip #define
|
|
if (!strncmp(p, "#define", 7))
|
|
{
|
|
//escape "\", "ie, #define .... \"
|
|
p += 7; //strlen(#define)
|
|
|
|
while (p < (utf8 + utf8_len))
|
|
{
|
|
char *eol = strstr(p, "\n");
|
|
if (!eol) goto end;
|
|
|
|
char *slash = strstr(p, "\\");
|
|
|
|
p = eol + 1;
|
|
|
|
if (!slash || (eol < slash))
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
//group?
|
|
if (!strncmp(p, group, group_len))
|
|
{
|
|
p += group_len;
|
|
|
|
if (((*p != ' ') && (*p != '{') && (*p != '\n') && (*p != '\t')))
|
|
continue;
|
|
|
|
p++;
|
|
|
|
//We found a group
|
|
p = strstr(p, quot);
|
|
if (!p) goto end;
|
|
|
|
p++;
|
|
char *name_begin = p;
|
|
|
|
p = strstr(p, quot);
|
|
if (!p) goto end;
|
|
|
|
char *name_end = p;
|
|
|
|
group_name = eina_stringshare_add_length(name_begin,
|
|
name_end - name_begin);
|
|
if (group_name)
|
|
group_list = eina_list_append(group_list, group_name);
|
|
}
|
|
p++;
|
|
}
|
|
|
|
end:
|
|
free(utf8);
|
|
|
|
return group_list;
|
|
}
|
|
|
|
char*
|
|
parser_group_pos_get(char *utf8, char *utf8_end,
|
|
const char *group_name)
|
|
{
|
|
char *p = utf8;
|
|
char *result = NULL;
|
|
|
|
int group_name_len = strlen(group_name);
|
|
|
|
//Find group
|
|
while (utf8_end > p)
|
|
{
|
|
//Skip " ~ " Section
|
|
if (*p == '\"')
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
|
|
if (!strncmp("group", p, strlen("group")))
|
|
{
|
|
p = strstr((p + 5), "\"");
|
|
if (!p) return NULL;
|
|
p++;
|
|
if (!strncmp(group_name, p, group_name_len))
|
|
{
|
|
//Compare Elaborately
|
|
char *next_quote = strstr(p, "\"");
|
|
if (group_name_len == (next_quote - p))
|
|
{
|
|
result = p;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
char*
|
|
parser_part_pos_get(char *utf8, char *utf8_end,
|
|
const char* group_name,
|
|
const char *part_name, const char *part_type)
|
|
{
|
|
char *p = parser_group_pos_get(utf8, utf8_end, group_name);
|
|
|
|
//No found
|
|
if (!p) return NULL;
|
|
|
|
p = strstr(p, "\"");
|
|
if (!p) return NULL;
|
|
p++;
|
|
|
|
char *result = NULL;
|
|
|
|
//goto parts
|
|
p = strstr(p, "parts");
|
|
if (!p) return NULL;
|
|
|
|
int part_name_len = strlen(part_name);
|
|
|
|
//Find part
|
|
while (utf8_end > p)
|
|
{
|
|
//Skip " ~ " Section
|
|
if (*p == '\"')
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
|
|
if (!strncmp(part_type, p, strlen(part_type)))
|
|
{
|
|
p = strstr((p + strlen(part_type)), "\"");
|
|
if (!p) return NULL;
|
|
p++;
|
|
if (!strncmp(part_name, p, part_name_len))
|
|
{
|
|
//Compare Elaborately
|
|
char *next_quote = strstr(p, "\"");
|
|
if (part_name_len == (next_quote - p))
|
|
{
|
|
result = p;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
}
|
|
|
|
//compatibility: "part"
|
|
if (!strncmp("part", p, strlen("part")))
|
|
{
|
|
p = strstr((p + 4), "\"");
|
|
if (!p) return NULL;
|
|
p++;
|
|
if (!strncmp(part_name, p, strlen(part_name)))
|
|
{
|
|
//Compare Elaborately
|
|
char *next_quote = strstr(p, "\"");
|
|
if (part_name_len == (next_quote - p))
|
|
{
|
|
result = p;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ESCAPE_RET_NULL();
|
|
}
|
|
}
|
|
|
|
p++;
|
|
}
|
|
|
|
return result;
|
|
}
|