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.
 
 
 
 

800 lines
25 KiB

#ifndef EFL_BETA_API_SUPPORT
#define EFL_BETA_API_SUPPORT
#endif
#ifndef EFL_EO_API_SUPPORT
#define EFL_EO_API_SUPPORT
#endif
#include <Ecore.h>
#include <Ecore_Getopt.h>
#include <Ecore_Evas.h>
#include <Elementary.h>
#include "tsuite_file_data.h"
typedef struct
{
int w;
int h;
void *pixels;
int pixels_len;
} Exactness_Image;
typedef struct
{
void *p1;
void *p2;
} _Two_Ptrs;
typedef struct
{
Lists_st *scn;
// Exactness_Scenario *scn;
Eina_List *imgs; /* List of Exactness_Image */
} Exactness_Unit;
static Eo *_main_box = NULL;
static Eina_List *_gls = NULL;
static Eina_List *_units = NULL;
static Elm_Genlist_Item_Class *_grp_itc = NULL, *_scn_itc = NULL, *_img_itc = NULL;
static Elm_Genlist_Item_Class *_comp_scn_itc = NULL, *_comp_img_itc = NULL;
static const char *
_event_name_get(const Variant_st *v)
{
switch(tsuite_event_mapping_type_get(v->t.type))
{
case TSUITE_EVENT_MOUSE_IN: return "Mouse In";
case TSUITE_EVENT_MOUSE_OUT: return "Mouse Out";
case TSUITE_EVENT_MOUSE_DOWN: return "Mouse Down";
case TSUITE_EVENT_MOUSE_UP: return "Mouse Up";
case TSUITE_EVENT_MOUSE_MOVE: return "Mouse Move";
case TSUITE_EVENT_MOUSE_WHEEL: return "Mouse Wheel";
case TSUITE_EVENT_MULTI_DOWN: return "Multi Down";
case TSUITE_EVENT_MULTI_UP: return "Multi Up";
case TSUITE_EVENT_MULTI_MOVE: return "Multi Move";
case TSUITE_EVENT_KEY_DOWN: return "Key Down";
case TSUITE_EVENT_KEY_UP: return "Key Up";
case TSUITE_EVENT_KEY_DOWN_WITH_KEYCODE: return "Key Down with Keycode";
case TSUITE_EVENT_KEY_UP_WITH_KEYCODE: return "Key Up with Keycode";
case TSUITE_EVENT_TAKE_SHOT: return "Take shot";
default: return NULL;
}
}
static int
_event_struct_len_get(Tsuite_Event_Type type)
{
switch(type)
{
case TSUITE_EVENT_MOUSE_IN: case TSUITE_EVENT_MOUSE_OUT: return sizeof(mouse_in_mouse_out);
case TSUITE_EVENT_MOUSE_DOWN: case TSUITE_EVENT_MOUSE_UP: return sizeof(mouse_down_mouse_up);
case TSUITE_EVENT_MOUSE_MOVE: return sizeof(mouse_move);
case TSUITE_EVENT_MOUSE_WHEEL: return sizeof(mouse_wheel);
case TSUITE_EVENT_MULTI_DOWN: case TSUITE_EVENT_MULTI_UP: return sizeof(multi_move);
case TSUITE_EVENT_MULTI_MOVE: return sizeof(multi_event);
case TSUITE_EVENT_KEY_DOWN: case TSUITE_EVENT_KEY_UP: return sizeof(key_down_key_up);
case TSUITE_EVENT_KEY_DOWN_WITH_KEYCODE: case TSUITE_EVENT_KEY_UP_WITH_KEYCODE: return sizeof(key_down_key_up_with_keycode);
case TSUITE_EVENT_TAKE_SHOT: return sizeof(take_screenshot);
default: return 0;
}
}
static void
_event_specific_info_get(const Variant_st *v, char output[1024])
{
switch(tsuite_event_mapping_type_get(v->t.type))
{
case TSUITE_EVENT_MOUSE_DOWN:
{
mouse_down_mouse_up *t = v->data;
sprintf(output, "Button %d Flags %d", t->b, t->flags);
break;
}
case TSUITE_EVENT_MOUSE_UP:
{
mouse_down_mouse_up *t = v->data;
sprintf(output, "Button %d Flags %d", t->b, t->flags);
break;
}
case TSUITE_EVENT_MOUSE_MOVE:
{
mouse_move *t = v->data;
sprintf(output, "X %d Y %d", t->x, t->y);
break;
}
case TSUITE_EVENT_MOUSE_WHEEL:
{
mouse_wheel *t = v->data;
sprintf(output, "Direction %d Z %d", t->direction, t->z);
break;
}
case TSUITE_EVENT_MULTI_DOWN: case TSUITE_EVENT_MULTI_UP:
{
multi_event *t = v->data;
if (!t->d)
sprintf(output, "Button %d Flags %d", t->b, t->flags);
else
sprintf(output, "D %d X %d Y %d Rad %f RadX %f RadY %f Pres %f Ang %f FX %f FY %f Flags %d",
t->d, t->x, t->y, t->rad, t->radx, t->rady, t->pres, t->ang, t->fx, t->fy, t->flags);
break;
}
case TSUITE_EVENT_MULTI_MOVE:
{
multi_move *t = v->data;
if (!t->d)
sprintf(output, "X %d Y %d", t->x, t->y);
else
sprintf(output, "D %d X %d Y %d Rad %f RadX %f RadY %f Pres %f Ang %f FX %f FY %f",
t->d, t->x, t->y, t->rad, t->radx, t->rady, t->pres, t->ang, t->fx, t->fy);
break;
}
case TSUITE_EVENT_KEY_UP: case TSUITE_EVENT_KEY_DOWN:
{
key_down_key_up *t = v->data;
sprintf(output, "Keyname %s Key %s String %s Compose %s",
t->keyname, t->key, t->string, t->compose);
break;
}
case TSUITE_EVENT_KEY_DOWN_WITH_KEYCODE: case TSUITE_EVENT_KEY_UP_WITH_KEYCODE:
{
key_down_key_up_with_keycode *t = v->data;
sprintf(output, "Keyname %s Key %s String %s Compose %s Keycode %d",
t->keyname, t->key, t->string, t->compose, t->keycode);
break;
}
default:
{
output[0] = '\0';
break;
}
}
}
static const Ecore_Getopt optdesc = {
"exactness_inspect",
"%prog [options] [<rec file> | <file1 file2>]",
NULL,
"(C) 2016 Enlightenment",
"BSD",
"Inspector for Exactness",
0,
{
ECORE_GETOPT_STORE_USHORT('d', "delay", "Delay the given recording by a given time (in milliseconds)."),
ECORE_GETOPT_STORE_TRUE('c', "clean", "Clean the given recording from wrong events."),
ECORE_GETOPT_STORE_TRUE('l', "list", "List the events of the given recording."),
ECORE_GETOPT_STORE_TRUE('C', "compare", "Compare given files (images files or objects eet files)."),
ECORE_GETOPT_STORE_STR('o', "compare_output", "Output of the comparison."),
ECORE_GETOPT_STORE_USHORT('s', "shot", "Select a specific shot (1 = 1st shot...)."),
ECORE_GETOPT_LICENSE('L', "license"),
ECORE_GETOPT_COPYRIGHT('C', "copyright"),
ECORE_GETOPT_VERSION('V', "version"),
ECORE_GETOPT_HELP('h', "help"),
ECORE_GETOPT_SENTINEL
}
};
static Eina_Bool
_is_hook_duplicate(const Variant_st *cur_v, const Variant_st *prev_v)
{
if (!prev_v) return EINA_FALSE;
Tsuite_Event_Type cur_type = tsuite_event_mapping_type_get(cur_v->t.type);
Tsuite_Event_Type prev_type = tsuite_event_mapping_type_get(prev_v->t.type);
if (cur_type == prev_type &&
!memcmp(cur_v->data, prev_v->data, _event_struct_len_get(cur_type))) return EINA_TRUE;
return EINA_FALSE;
}
static Exactness_Image *
_pixels_compare(Exactness_Image *img1, Exactness_Image *img2, Eina_Bool *has_diff)
{
Exactness_Image *imgO = malloc(sizeof(*imgO));
int w, h;
int *pxs1, *pxs2, *pxsO;
int w1 = img1 ? img1->w : 0, h1 = img1 ? img1->h : 0;
int w2 = img2 ? img2->w : 0, h2 = img2 ? img2->h : 0;
imgO->w = MAX(w1, w2);
imgO->h = MAX(h1, h2);
if (has_diff) *has_diff = EINA_FALSE;
if (!imgO->w || !imgO->h)
{
free(imgO);
return NULL;
}
imgO->pixels_len = imgO->w * imgO->h *4;
imgO->pixels = malloc(imgO->pixels_len);
pxs1 = img1 ? img1->pixels : NULL;
pxs2 = img2 ? img2->pixels : NULL;
pxsO = imgO->pixels;
for (w = 0; w < imgO->w; w++)
{
for (h = 0; h < imgO->h; h++)
{
Eina_Bool valid1 = w <= w1 && h <= h1;
Eina_Bool valid2 = w <= w2 && h <= h2;
int px1 = valid1 ? pxs1[h * w1 + w] : 0;
int px2 = valid2 ? pxs2[h * w2 + w] : 0;
int r1 = (px1 & 0x00FF0000) >> 16;
int r2 = (px2 & 0x00FF0000) >> 16;
int g1 = (px1 & 0x0000FF00) >> 8;
int g2 = (px2 & 0x0000FF00) >> 8;
int b1 = (px1 & 0x000000FF);
int b2 = (px2 & 0x000000FF);
int new_r, new_g, new_b;
if (valid1 || valid2)
{
if (px1 != px2)
{
new_r = 0xFF;
new_g = ((g1 + g2) >> 1) >> 2;
new_b = ((b1 + b2) >> 1) >> 2;
if (has_diff) *has_diff = EINA_TRUE;
}
else
{
new_r = (((r1 + r2) >> 1) >> 2) + 0xC0;
new_g = (((g1 + g2) >> 1) >> 2) + 0xC0;
new_b = (((b1 + b2) >> 1) >> 2) + 0xC0;
}
}
else
{
new_r = new_g = new_b = 0x0;
}
pxsO[h * imgO->w + w] = 0xFF000000 | new_r << 16 | new_g << 8 | new_b;
}
}
return imgO;
}
static void
_gui_win_create()
{
Eo *win, *bg;
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
win = elm_win_add(NULL, "Window", ELM_WIN_BASIC);
elm_win_maximized_set(win, EINA_TRUE);
elm_win_autodel_set(win, EINA_TRUE);
elm_win_title_set(win, "Exactness Inspector");
efl_gfx_entity_size_set(win, EINA_SIZE2D(1000, 800));
bg = elm_bg_add(win);
evas_object_size_hint_weight_set(bg, 1.000000, 1.000000);
efl_gfx_entity_visible_set(bg, EINA_TRUE);
elm_win_resize_object_add(win, bg);
_main_box = elm_box_add(win);
elm_box_horizontal_set(_main_box, EINA_TRUE);
elm_box_homogeneous_set(_main_box, EINA_TRUE);
evas_object_size_hint_weight_set(_main_box, 1.000000, 1.000000);
efl_gfx_entity_visible_set(_main_box, EINA_TRUE);
elm_win_resize_object_add(win, _main_box);
efl_gfx_entity_visible_set(win, EINA_TRUE);
}
static char *
_grp_text_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part EINA_UNUSED)
{
return strdup(data);
}
static char *
_scn_text_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part EINA_UNUSED)
{
Variant_st *v = data;
Eina_Strbuf *buf = eina_strbuf_new();
char *ret = NULL;
unsigned int timestamp = evt_time_get(0, v);
char specific_output[1024];
if (!timestamp) eina_strbuf_append(buf, "BAD_TIME: ");
else eina_strbuf_append_printf(buf, "%.3f: ", timestamp / 1000.0);
eina_strbuf_append_printf(buf, "%s", _event_name_get(v));
_event_specific_info_get(v, specific_output);
if (*specific_output) eina_strbuf_append_printf(buf, " - %s", specific_output);
ret = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return ret;
}
static char *
_comp_scn_text_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part EINA_UNUSED)
{
_Two_Ptrs *vv = data;
Variant_st *v1 = vv->p1;
Variant_st *v2 = vv->p2;
int tm1 = evt_time_get(0, v1);
int tm2 = evt_time_get(0, v2);
Tsuite_Event_Type t1 = tsuite_event_mapping_type_get(v1->t.type);
Tsuite_Event_Type t2 = tsuite_event_mapping_type_get(v2->t.type);
Eina_Strbuf *buf = eina_strbuf_new();
char *ret = NULL;
if (tm1 != tm2) eina_strbuf_append_printf(buf, "[%.3f/%.3f]: ", tm1/1000.0, tm2/1000.0);
else eina_strbuf_append_printf(buf, "%.3f: ", tm1 / 1000.0);
if (t1 != t2)
eina_strbuf_append_printf(buf, "[%s/%s] - XXXXXX", _event_name_get(v1), _event_name_get(v2));
else
{
char params1[1024];
char params2[2024];
_event_specific_info_get(v1, params1);
_event_specific_info_get(v2, params2);
eina_strbuf_append_printf(buf, "%s", _event_name_get(v1));
if (*params1 || *params2)
{
if (strcmp(params1, params2))
eina_strbuf_append_printf(buf, " - [%s/%s]", params1, params2);
else
eina_strbuf_append_printf(buf, " - %s", params1);
}
}
ret = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return ret;
}
static Evas_Object *
_img_content_get(void *data, Evas_Object *obj, const char *part)
{
if (strcmp(part, "elm.swallow.content")) return NULL;
Exactness_Image *ex_img = data;
Eo *img = elm_image_add(obj);
Eo *evas_img = elm_image_object_get(img);
evas_object_image_size_set(evas_img, ex_img->w, ex_img->h);
evas_object_image_data_set(evas_img, ex_img->pixels);
evas_object_size_hint_min_set(img, ELM_SCALE_SIZE(300), ELM_SCALE_SIZE(300));
return img;
}
static Evas_Object *
_comp_img_content_get(void *data, Evas_Object *obj, const char *part)
{
if (strcmp(part, "elm.swallow.content")) return NULL;
_Two_Ptrs *vv = data;
Exactness_Image *img1 = vv->p1;
Exactness_Image *img2 = vv->p2;
Exactness_Image *imgO = _pixels_compare(img1, img2, NULL);
Eo *img = elm_image_add(obj);
Eo *evas_img = elm_image_object_get(img);
evas_object_image_size_set(evas_img, imgO->w, imgO->h);
evas_object_image_data_set(evas_img, imgO->pixels);
evas_object_size_hint_min_set(img, ELM_SCALE_SIZE(300), ELM_SCALE_SIZE(300));
return img;
}
static void
_itc_init()
{
if (!_grp_itc)
{
_grp_itc = elm_genlist_item_class_new();
_grp_itc->item_style = "group_index";
_grp_itc->func.text_get = _grp_text_get;
}
if (!_scn_itc)
{
_scn_itc = elm_genlist_item_class_new();
_scn_itc->item_style = "default";
_scn_itc->func.text_get = _scn_text_get;
}
if (!_img_itc)
{
_img_itc = elm_genlist_item_class_new();
_img_itc->item_style = "full";
_img_itc->func.content_get = _img_content_get;
}
if (!_comp_scn_itc)
{
_comp_scn_itc = elm_genlist_item_class_new();
_comp_scn_itc->item_style = "default";
_comp_scn_itc->func.text_get = _comp_scn_text_get;
}
if (!_comp_img_itc)
{
_comp_img_itc = elm_genlist_item_class_new();
_comp_img_itc->item_style = "full";
_comp_img_itc->func.content_get = _comp_img_content_get;
}
}
static void
_comp_gl_dragged_cb(Evas_Object *obj, void *data EINA_UNUSED)
{
int x = 0, y = 0;
Eo *gl;
Eina_List *itr;
elm_interface_scrollable_content_pos_get(obj, &x, &y);
EINA_LIST_FOREACH(_gls, itr, gl)
{
if (gl != obj)
elm_interface_scrollable_content_pos_set(gl, x, y, EINA_FALSE);
}
}
static void
_gui_unit_display(Exactness_Unit *unit1, Exactness_Unit *unit2, int position)
{
Eina_List *itr1, *itr2;
Eo *gl;
gl = elm_genlist_add(_main_box);
elm_genlist_homogeneous_set(gl, EINA_TRUE);
evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
efl_gfx_visible_set(gl, EINA_TRUE);
_gls = eina_list_append(_gls, gl);
if (position == -1) elm_box_pack_end(_main_box, gl);
else if (position == 0) elm_box_pack_start(_main_box, gl);
else
{
Eina_List *children = elm_box_children_get(_main_box);
Eo *before = eina_list_nth(children, position - 1);
elm_box_pack_after(_main_box, gl, before);
eina_list_free(children);
}
if (unit2)
{
elm_interface_scrollable_vbar_drag_cb_set(gl, _comp_gl_dragged_cb);
}
_itc_init();
itr1 = unit1 && unit1->scn ? unit1->scn->variant_list : NULL;
itr2 = unit2 && unit2->scn ? unit2->scn->variant_list : NULL;
if (itr1)
elm_genlist_item_append(gl, _grp_itc, "Scenario", NULL, ELM_GENLIST_ITEM_GROUP, NULL, NULL);
while (itr1 || itr2)
{
Variant_st *v1 = itr1 ? eina_list_data_get(itr1) : NULL;
if (unit2)
{
Variant_st *v2 = itr2 ? eina_list_data_get(itr2) : NULL;
_Two_Ptrs *vv = malloc(sizeof(*vv));
vv->p1 = v1;
vv->p2 = v2;
elm_genlist_item_append(gl, _comp_scn_itc, vv, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
}
else
{
elm_genlist_item_append(gl, _scn_itc, v1, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
}
if (itr1) itr1 = eina_list_next(itr1);
if (itr2) itr2 = eina_list_next(itr2);
}
itr1 = unit1 ? unit1->imgs : NULL;
itr2 = unit2 ? unit2->imgs : NULL;
if (itr1)
elm_genlist_item_append(gl, _grp_itc, "Images", NULL, ELM_GENLIST_ITEM_GROUP, NULL, NULL);
while (itr1 || itr2)
{
Exactness_Image *img1 = itr1 ? eina_list_data_get(itr1) : NULL;
if (unit2)
{
Exactness_Image *img2 = itr2 ? eina_list_data_get(itr2) : NULL;
_Two_Ptrs *vv = malloc(sizeof(*vv));
vv->p1 = img1;
vv->p2 = img2;
elm_genlist_item_append(gl, _comp_img_itc, vv, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
}
else
{
elm_genlist_item_append(gl, _img_itc, img1, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
}
if (itr1) itr1 = eina_list_next(itr1);
if (itr2) itr2 = eina_list_next(itr2);
}
}
static Exactness_Image *
_image_read(const char *filename)
{
int w, h;
Evas_Load_Error err;
Ecore_Evas *ee = ecore_evas_new(NULL, 0, 0, 100, 100, NULL);
/* the canvas pointer, de facto */
Eo *e = ecore_evas_get(ee);
Eo *img = evas_object_image_add(e);
evas_object_image_file_set(img, filename, NULL);
err = evas_object_image_load_error_get(img);
if (err != EVAS_LOAD_ERROR_NONE)
{
fprintf(stderr, "could not load image '%s'. error string is \"%s\"\n",
filename, evas_load_error_str(err));
return NULL;
}
Exactness_Image *ex_img = malloc(sizeof(*ex_img));
int len;
evas_object_image_size_get(img, &w, &h);
ex_img->w = w;
ex_img->h = h;
ex_img->pixels_len = w * h * 4;
len = ex_img->pixels_len;
ex_img->pixels = malloc(len);
memcpy(ex_img->pixels, evas_object_image_data_get(img, EINA_FALSE), len);
ecore_evas_free(ee);
return ex_img;
}
int
main(int argc, char *argv[])
{
const char *ext = NULL;
const char *rec_file = NULL;
char *compare_output = NULL;
int ret = 1, args = 0;
unsigned short delay = 0, shot = 0;
Eina_Bool write_file = EINA_FALSE;
Eina_Bool want_quit, clean = EINA_FALSE, list_get = EINA_FALSE, compare_files = EINA_FALSE;
Eina_Bool gui_needed = EINA_TRUE;
Ecore_Getopt_Value values[] = {
ECORE_GETOPT_VALUE_USHORT(delay),
ECORE_GETOPT_VALUE_BOOL(clean),
ECORE_GETOPT_VALUE_BOOL(list_get),
ECORE_GETOPT_VALUE_BOOL(compare_files),
ECORE_GETOPT_VALUE_STR(compare_output),
ECORE_GETOPT_VALUE_USHORT(shot),
ECORE_GETOPT_VALUE_BOOL(want_quit),
ECORE_GETOPT_VALUE_BOOL(want_quit),
ECORE_GETOPT_VALUE_BOOL(want_quit),
ECORE_GETOPT_VALUE_BOOL(want_quit),
ECORE_GETOPT_VALUE_NONE
};
ecore_evas_init();
ecore_init();
eet_init();
elm_init(0, NULL);
want_quit = EINA_FALSE;
args = ecore_getopt_parse(&optdesc, values, argc, argv);
if (args < 0)
{
fprintf(stderr, "Failed parsing arguments.\n");
goto end;
}
else if (want_quit)
{
goto end;
}
else if ((clean || delay || shot || list_get) && args == argc)
{
fprintf(stderr, "Expected rec file as the last argument.\n");
ecore_getopt_help(stderr, &optdesc);
goto end;
}
else if (shot && !delay)
{
fprintf(stderr, "shot option can only be used with delay option.\n");
goto end;
}
else if (compare_files && argc - args < 2)
{
fprintf(stderr, "Expected at least two files to compare as last arguments.\n");
ecore_getopt_help(stderr, &optdesc);
goto end;
}
Lists_st *list = NULL;
if (clean || delay || list_get)
{
rec_file = argv[args];
Timer_Data td;
gui_needed = EINA_FALSE;
list = read_events(rec_file, &td);
}
else
{
int arg;
if (compare_output) gui_needed = EINA_FALSE;
for (arg = args; arg < argc; arg++)
{
if (!ext) ext = strrchr(argv[arg], '.');
if (!ext)
{
fprintf(stderr, "Extension required\n");
goto end;
}
if (!strcmp(ext, ".rec"))
{
Exactness_Unit *ex_unit = calloc(1, sizeof(*ex_unit));
Timer_Data td;
Variant_st *v;
Eina_List *itr;
list = read_events(argv[arg], &td);
if (!list)
{
fprintf(stderr, "Issue while reading %s\n", argv[arg]);
goto end;
}
EINA_LIST_FOREACH(list->variant_list, itr, v)
{
unsigned int tm = evt_time_get(0, v);
if (tm) evt_time_set(tm - list->first_timestamp, v);
}
ex_unit->scn = list;
_units = eina_list_append(_units, ex_unit);
}
else if (!strcmp(ext, ".png"))
{
Exactness_Unit *ex_unit = calloc(1, sizeof(*ex_unit));
Exactness_Image *ex_img = _image_read(argv[arg]);
if (!ex_img)
{
fprintf(stderr, "Issue while reading %s\n", argv[arg]);
goto end;
}
ex_unit->imgs = eina_list_append(ex_unit->imgs, ex_img);
_units = eina_list_append(_units, ex_unit);
}
}
}
if (clean)
{
Variant_st *v;
Eina_List *itr, *itr2;
EINA_LIST_FOREACH_SAFE(list->variant_list, itr, itr2, v)
{
if (!evt_time_get(0, v))
list->variant_list = eina_list_remove_list(list->variant_list, itr);
else
{
if (_is_hook_duplicate(v, eina_list_data_get(eina_list_prev(itr))))
list->variant_list = eina_list_remove_list(list->variant_list, itr);
}
}
if (!list->first_timestamp)
{
list->first_timestamp = evt_time_get(0, eina_list_data_get(list->variant_list));
}
write_file = EINA_TRUE;
}
if (delay)
{
if (!shot)
{
if (!list->first_timestamp)
{
list->first_timestamp = evt_time_get(0, eina_list_data_get(list->variant_list));
}
list->first_timestamp -= delay;
}
else
{
Variant_st *v;
Eina_List *itr;
unsigned int cur_shot = 0;
EINA_LIST_FOREACH(list->variant_list, itr, v)
{
if (tsuite_event_mapping_type_get(v->t.type) == TSUITE_EVENT_TAKE_SHOT)
{
cur_shot++;
if (cur_shot == shot)
{
take_screenshot *t = v->data;
t->timestamp += delay;
break;
}
}
}
}
write_file = EINA_TRUE;
}
if (list_get)
{
Variant_st *v;
Eina_List *itr;
printf("First timestamp: ");
if (list->first_timestamp) printf("%u\n", list->first_timestamp);
else printf("undefined\n");
EINA_LIST_FOREACH(list->variant_list, itr, v)
{
char specific_output[1024];
unsigned int timestamp = evt_time_get(0, v);
if (!timestamp) printf("BAD_TIME: ");
else printf("%.3f: ", (list->first_timestamp ? timestamp - list->first_timestamp : timestamp) / 1000.0);
printf("%s", _event_name_get(v));
_event_specific_info_get(v, specific_output);
if (*specific_output) printf(" - %s", specific_output);
printf("\n");
}
}
if (compare_files && compare_output)
{
Exactness_Unit *unit1 = NULL, *unit2 = NULL;
Eina_List *itr;
Exactness_Unit *unit;
EINA_LIST_FOREACH(_units, itr, unit)
{
if (!unit1) unit1 = unit;
else if (!unit2) unit2 = unit;
else
{
fprintf(stderr, "Too much files to compare (only 2).");
goto end;
}
}
if (!strcmp(ext, ".png"))
{
Eina_Bool has_diff = EINA_FALSE;
Exactness_Image *ex_img1 = eina_list_data_get(unit1->imgs);
Exactness_Image *ex_img2 = eina_list_data_get(unit2->imgs);
Exactness_Image *ex_imgO = _pixels_compare(ex_img1, ex_img2, &has_diff);
if (has_diff)
{
Ecore_Evas *ee;
Eo *e, *img;
ee = ecore_evas_new(NULL, 0, 0, 100, 100, NULL);
e = ecore_evas_get(ee);
img = evas_object_image_add(e);
evas_object_image_size_set(img, ex_imgO->w, ex_imgO->h);
evas_object_image_data_set(img, ex_imgO->pixels);
evas_object_image_save(img, compare_output, NULL, NULL);
ecore_evas_free(ee);
goto end;
}
}
}
ret = 0;
if (rec_file && write_file) write_events(rec_file, list);
if (gui_needed)
{
Eina_List *itr;
Exactness_Unit *unit, *unit1 = NULL, *unit2 = NULL;
Eina_Bool need_compare = compare_files && eina_list_count(_units) == 2;
_gui_win_create();
EINA_LIST_FOREACH(_units, itr, unit)
{
if (need_compare)
{
if (!unit1) unit1 = unit;
else unit2 = unit;
}
_gui_unit_display(unit, NULL, -1);
}
if (need_compare)
{
_gui_unit_display(unit1, unit2, 1);
}
elm_run();
}
end:
elm_shutdown();
eet_shutdown();
ecore_shutdown();
ecore_evas_shutdown();
return ret;
}