2015-07-02 05:02:04 -07:00
|
|
|
/*
|
|
|
|
gcc evlog.c -o evlog `pkg-config --cflags --libs elementary`
|
|
|
|
edje_cc evlog.edc -id ./img
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <Elementary.h>
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
#define RES 100000.0
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
Evas_Object *win;
|
|
|
|
Evas_Object *zoom_slider;
|
|
|
|
|
|
|
|
typedef struct _Evlog Evlog;
|
2015-10-15 20:25:02 -07:00
|
|
|
typedef struct _Evlog_Thread Evlog_Thread;
|
|
|
|
typedef struct _Evlog_Event Evlog_Event;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
struct _Evlog
|
|
|
|
{
|
|
|
|
FILE *file;
|
2015-10-15 20:25:02 -07:00
|
|
|
double first_timestamp;
|
|
|
|
double last_timestamp;
|
|
|
|
int state_num;
|
|
|
|
int thread_num;
|
|
|
|
Evlog_Event *states;
|
|
|
|
Evlog_Thread *threads;
|
2015-07-02 05:02:04 -07:00
|
|
|
};
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
struct _Evlog_Event
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
const char *event;
|
|
|
|
// const char *detail;
|
|
|
|
double timestamp;
|
|
|
|
double latency;
|
2015-07-02 05:02:04 -07:00
|
|
|
};
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
struct _Evlog_Thread
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
unsigned long long id;
|
|
|
|
int event_num;
|
|
|
|
Evlog_Event *events;
|
2015-07-02 05:02:04 -07:00
|
|
|
};
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
typedef struct
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Evlog *evlog;
|
|
|
|
Evas_Object *win;
|
|
|
|
Evas_Object *scroller;
|
|
|
|
Evas_Object *table;
|
|
|
|
struct {
|
|
|
|
Evas_Object *state;
|
|
|
|
Evas_Object **thread;
|
|
|
|
Evas_Object *over;
|
|
|
|
} grid;
|
|
|
|
Eina_List *objs;
|
|
|
|
struct {
|
|
|
|
Ecore_Job *job;
|
|
|
|
Ecore_Thread *thread;
|
|
|
|
double t0, t1, tmin;
|
|
|
|
Eina_Bool redo : 1;
|
|
|
|
Eina_List *remobjs;
|
|
|
|
} update;
|
|
|
|
} Inf;
|
|
|
|
|
|
|
|
typedef struct
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
void *src;
|
|
|
|
char *event;
|
|
|
|
Evas_Object *obj;
|
|
|
|
double t0, t1;
|
|
|
|
int n;
|
|
|
|
int slot;
|
|
|
|
Eina_Bool nuke : 1;
|
|
|
|
} Event;
|
|
|
|
|
|
|
|
#define ROUND_AMOUNT 1024
|
|
|
|
#define ROUND(x) ((x + (ROUND_AMOUNT - 1)) / ROUND_AMOUNT) * ROUND_AMOUNT;
|
|
|
|
|
|
|
|
static void _fill_begin(Inf *inf);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2015-10-15 20:25:02 -07:00
|
|
|
evlog_state_event_register(Evlog *evlog, Evlog_Event *ev)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
int n0, n;
|
|
|
|
|
|
|
|
n0 = evlog->state_num;
|
|
|
|
evlog->state_num++;
|
|
|
|
n = evlog->state_num;
|
|
|
|
n0 = ROUND(n0);
|
|
|
|
n = ROUND(n);
|
|
|
|
if (n != n0)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Evlog_Event *tmp;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
tmp = realloc(evlog->states, n * sizeof(Evlog_Event));
|
|
|
|
if (!tmp)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(ev->event);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
evlog->states = tmp;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
evlog->states[evlog->state_num - 1] = *ev;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-10-15 20:25:02 -07:00
|
|
|
evlog_thread_event_register(Evlog_Thread *th, Evlog_Event *ev)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
int n0, n;
|
|
|
|
|
|
|
|
n0 = th->event_num;
|
|
|
|
th->event_num++;
|
|
|
|
n = th->event_num;
|
|
|
|
n0 = ROUND(n0);
|
|
|
|
n = ROUND(n);
|
|
|
|
if (n != n0)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Evlog_Event *tmp;
|
|
|
|
|
|
|
|
tmp = realloc(th->events, n * sizeof(Evlog_Event));
|
|
|
|
if (!tmp)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(ev->event);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
th->events = tmp;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
th->events[th->event_num - 1] = *ev;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-10-15 20:25:02 -07:00
|
|
|
evlog_event_register(Evlog *evlog, unsigned long long thread, Evlog_Event *ev)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
if ((ev->event[0] == '<') || (ev->event[0] == '>'))
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
evlog_state_event_register(evlog, ev);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
else
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
for (i = 0; i < evlog->thread_num; i++)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
if (evlog->threads[i].id == thread) break;
|
|
|
|
}
|
|
|
|
if (i >= evlog->thread_num)
|
|
|
|
{
|
|
|
|
Evlog_Thread *tmp;
|
|
|
|
|
|
|
|
evlog->thread_num++;
|
|
|
|
tmp = realloc(evlog->threads,
|
|
|
|
evlog->thread_num * sizeof(Evlog_Thread));
|
|
|
|
if (!tmp)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(ev->event);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
evlog->threads = tmp;
|
|
|
|
evlog->threads[i].id = thread;
|
|
|
|
evlog->threads[i].event_num = 0;
|
|
|
|
evlog->threads[i].events = NULL;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
evlog_thread_event_register(&(evlog->threads[i]), ev);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
static void *
|
|
|
|
evlog_event_read(Evlog *evlog, void *ptr, void *end)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
unsigned char *data = ptr;
|
|
|
|
unsigned char *dataend = end;
|
|
|
|
const char *eventstr = NULL, *detailstr = NULL;
|
|
|
|
Eina_Evlog_Item item;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
if ((dataend - data) < sizeof(Eina_Evlog_Item)) return NULL;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
memcpy(&item, data, sizeof(Eina_Evlog_Item));
|
|
|
|
|
|
|
|
if (item.event_offset >= sizeof(Eina_Evlog_Item))
|
|
|
|
eventstr = data + item.event_offset;
|
|
|
|
if (item.detail_offset >= sizeof(Eina_Evlog_Item))
|
|
|
|
detailstr = data + item.detail_offset;
|
|
|
|
if (eventstr)
|
|
|
|
{
|
|
|
|
Evlog_Event ev;
|
|
|
|
ev.event = eina_stringshare_add(eventstr);
|
|
|
|
ev.timestamp = (item.srctim == 0.0) ? item.tim : item.srctim;
|
|
|
|
ev.latency = (item.srctim != 0.0) ? item.tim - item.srctim : 0.0;
|
|
|
|
if (evlog->first_timestamp == 0.0)
|
|
|
|
evlog->first_timestamp = ev.timestamp;
|
|
|
|
if (ev.timestamp > evlog->last_timestamp)
|
|
|
|
evlog->last_timestamp = ev.timestamp;
|
|
|
|
evlog_event_register(evlog, item.thread, &ev);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
|
|
|
|
data += item.event_next;
|
|
|
|
if (data >= dataend) return NULL;
|
|
|
|
return data;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
static Eina_Bool
|
|
|
|
evlog_block_read(Evlog *evlog)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
unsigned int header[3];
|
|
|
|
Eina_Bool bigendian = EINA_FALSE;
|
|
|
|
|
|
|
|
if (fread(header, 12, 1, evlog->file) != 1) return EINA_FALSE;
|
|
|
|
if (header[0] == 0x0ffee211) bigendian = EINA_FALSE;
|
|
|
|
else if (header[0] == 0x11e2fe0f) bigendian = EINA_TRUE;
|
|
|
|
else return EINA_FALSE;
|
|
|
|
if (!bigendian)
|
|
|
|
{
|
|
|
|
unsigned int blocksize = header[1];
|
|
|
|
unsigned int overflow = header[2];
|
|
|
|
void *buf = malloc(blocksize);
|
|
|
|
if (buf)
|
|
|
|
{
|
|
|
|
void *ptr, *end;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
if (fread(buf, blocksize, 1, evlog->file) != 1)
|
|
|
|
{
|
|
|
|
free(buf);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
ptr = buf;
|
|
|
|
end = ptr + blocksize;
|
|
|
|
while ((ptr = evlog_event_read(evlog, ptr, end)));
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
// XXX: handle bigendian
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
return EINA_TRUE;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Evlog *
|
|
|
|
evlog_new(const char *file)
|
|
|
|
{
|
|
|
|
Evlog *evlog = calloc(1, sizeof(Evlog));
|
|
|
|
if (!evlog) return NULL;
|
|
|
|
evlog->file = fopen(file, "rb");
|
|
|
|
if (!evlog->file)
|
|
|
|
{
|
|
|
|
free(evlog);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
while (evlog_block_read(evlog));
|
2015-07-02 05:02:04 -07:00
|
|
|
return evlog;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
evlog_free(Evlog *evlog)
|
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
// XXX free other stuff
|
2015-07-02 05:02:04 -07:00
|
|
|
fclose(evlog->file);
|
|
|
|
free(evlog);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_can_see(double t0, double t1, double tmin, double t0in, double t1in)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
if (t1in >= 0.0)
|
|
|
|
{
|
|
|
|
if ((t0in <= t1) &&
|
|
|
|
(t1in >= t0) &&
|
|
|
|
((t1in - t0in) >= tmin))
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((t0in <= t1) &&
|
|
|
|
(t0in >= t0))
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
static Evas_Object *
|
|
|
|
_create_log_states(Evas_Object *win, Evlog *evlog, Evas_Object *zoom)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Evas_Object *o, *oo;
|
|
|
|
double len = evlog->last_timestamp - evlog->first_timestamp;
|
|
|
|
int i;
|
|
|
|
int h = 0;
|
|
|
|
Eina_List *events = NULL, *l;
|
|
|
|
Event *ev;
|
|
|
|
Evlog_Event *e;
|
|
|
|
double t;
|
|
|
|
|
|
|
|
o = elm_grid_add(win);
|
|
|
|
for (i = 0; i < evlog->state_num; i++)
|
|
|
|
{
|
|
|
|
e = &(evlog->states[i]);
|
|
|
|
t = e->timestamp - evlog->first_timestamp;
|
|
|
|
if (e->event[0] == '>')
|
|
|
|
{
|
|
|
|
ev = calloc(1, sizeof(Event));
|
|
|
|
if (ev)
|
|
|
|
{
|
|
|
|
ev->src = e;
|
|
|
|
ev->event = strdup(e->event + 1);
|
|
|
|
ev->t0 = t;
|
|
|
|
events = eina_list_append(events, ev);
|
|
|
|
ev->n = eina_list_count(events) - 1;
|
|
|
|
if ((ev->n + 1) > h) h = ev->n + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (e->event[0] == '<')
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(events, l, ev)
|
|
|
|
{
|
|
|
|
if (!strcmp(ev->event, e->event + 1))
|
|
|
|
{
|
|
|
|
ev->t1 = t;
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
events = eina_list_remove_list(events, l);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
t = evlog->last_timestamp - evlog->first_timestamp;
|
|
|
|
EINA_LIST_FREE(events, ev)
|
|
|
|
{
|
|
|
|
ev->t1 = t;
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
}
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
if (h < 1) h = 1;
|
|
|
|
elm_grid_size_set(o, len * RES, h);
|
|
|
|
double res = elm_slider_value_get(zoom);
|
|
|
|
res = res * res;
|
|
|
|
evas_object_size_hint_min_set(o, len * res, h * 20);
|
|
|
|
|
|
|
|
oo = evas_object_rectangle_add(evas_object_evas_get(win));
|
|
|
|
evas_object_color_set(oo, 24, 24, 24, 255);
|
|
|
|
elm_grid_pack(o, oo, 0, 0, len * RES, h);
|
|
|
|
evas_object_show(oo);
|
|
|
|
return o;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-10-15 20:25:02 -07:00
|
|
|
_add_log_state(Inf *inf, Event *ev)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Event *ev2;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
EINA_LIST_FOREACH(inf->objs, l, ev2)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
if (ev2->src == ev->src)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
return;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
inf->objs = eina_list_append(inf->objs, ev);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-10-15 20:25:02 -07:00
|
|
|
_fill_log_states(Inf *inf, Evlog *evlog, double t0, double t1, double tmin)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
Eina_List *events = NULL, *l;
|
|
|
|
Event *ev;
|
|
|
|
Evlog_Event *e;
|
|
|
|
double t;
|
|
|
|
|
|
|
|
for (i = 0; i < evlog->state_num; i++)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
e = &(evlog->states[i]);
|
|
|
|
t = e->timestamp - evlog->first_timestamp;
|
|
|
|
if (e->event[0] == '>')
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
ev = calloc(1, sizeof(Event));
|
|
|
|
if (ev)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
ev->src = e;
|
|
|
|
ev->event = strdup(e->event + 1);
|
|
|
|
ev->t0 = t;
|
|
|
|
events = eina_list_append(events, ev);
|
|
|
|
ev->n = eina_list_count(events) - 1;
|
|
|
|
ev->slot = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (e->event[0] == '<')
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(events, l, ev)
|
|
|
|
{
|
|
|
|
if (!strcmp(ev->event, e->event + 1))
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
ev->t1 = t;
|
|
|
|
if (_can_see(t0, t1, tmin, ev->t0, ev->t1))
|
|
|
|
_add_log_state(inf, ev);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
events = eina_list_remove_list(events, l);
|
|
|
|
break;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
t = evlog->last_timestamp - evlog->first_timestamp;
|
|
|
|
EINA_LIST_FREE(events, ev)
|
|
|
|
{
|
|
|
|
ev->t1 = t;
|
|
|
|
if (_can_see(t0, t1, tmin, ev->t0, ev->t1))
|
|
|
|
_add_log_state(inf, ev);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_create_log_thread(Evas_Object *win, Evlog *evlog, Evlog_Thread *th, int slot, Evas_Object *zoom)
|
|
|
|
{
|
|
|
|
Evas_Object *o, *oo;
|
|
|
|
double len = evlog->last_timestamp - evlog->first_timestamp;
|
|
|
|
int i, c;
|
|
|
|
int h = 0;
|
|
|
|
Eina_List *stack = NULL, *l;
|
|
|
|
Event *ev;
|
|
|
|
Evlog_Event *e;
|
|
|
|
double t;
|
|
|
|
|
|
|
|
o = elm_grid_add(win);
|
|
|
|
for (i = 0; i < th->event_num; i++)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
e = &(th->events[i]);
|
|
|
|
t = e->timestamp - evlog->first_timestamp;
|
|
|
|
if (e->event[0] == '+')
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
ev = calloc(1, sizeof(Event));
|
|
|
|
if (ev)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
ev->src = e;
|
|
|
|
stack = eina_list_append(stack, ev);
|
|
|
|
ev->event = strdup(e->event + 1);
|
|
|
|
ev->t0 = t;
|
|
|
|
ev->n = eina_list_count(stack) - 1;
|
|
|
|
if ((ev->n + 1) > h) h = ev->n + 1;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
}
|
|
|
|
else if (e->event[0] == '-')
|
|
|
|
{
|
|
|
|
l = eina_list_last(stack);
|
|
|
|
if (l)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
ev = l->data;
|
|
|
|
ev->t1 = t;
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
stack = eina_list_remove_list(stack, l);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (e->event[0] == '!')
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if (e->event[0] == '*')
|
|
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
t = evlog->last_timestamp - evlog->first_timestamp;
|
|
|
|
EINA_LIST_FREE(stack, ev)
|
|
|
|
{
|
|
|
|
ev->t1 = t;
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
if (h < 1) h = 1;
|
|
|
|
elm_grid_size_set(o, len * RES, h);
|
|
|
|
evas_object_size_hint_min_set(o, 1, h * 20);
|
|
|
|
|
|
|
|
oo = evas_object_rectangle_add(evas_object_evas_get(win));
|
|
|
|
c = 32 + ((slot % 2) * 16);
|
|
|
|
evas_object_color_set(oo, c, c, c, 255);
|
|
|
|
elm_grid_pack(o, oo, 0, 0, len * RES, h);
|
|
|
|
evas_object_show(oo);
|
|
|
|
return o;
|
|
|
|
}
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
static void
|
|
|
|
_add_log_event(Inf *inf, Event *ev)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Event *ev2;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(inf->objs, l, ev2)
|
|
|
|
{
|
|
|
|
if (ev2->src == ev->src)
|
|
|
|
{
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
inf->objs = eina_list_append(inf->objs, ev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_fill_log_thread(Inf *inf, Evlog *evlog, Evlog_Thread *th, int slot, double t0, double t1, double tmin)
|
|
|
|
{
|
|
|
|
Eina_List *stack = NULL, *l;
|
|
|
|
Event *ev;
|
|
|
|
int i;
|
|
|
|
int h = 0;
|
|
|
|
Evlog_Event *e;
|
|
|
|
double t;
|
|
|
|
|
|
|
|
for (i = 0; i < th->event_num; i++)
|
|
|
|
{
|
|
|
|
e = &(th->events[i]);
|
|
|
|
t = e->timestamp - evlog->first_timestamp;
|
|
|
|
if (e->event[0] == '+')
|
|
|
|
{
|
|
|
|
ev = calloc(1, sizeof(Event));
|
|
|
|
if (ev)
|
|
|
|
{
|
|
|
|
ev->src = e;
|
|
|
|
stack = eina_list_append(stack, ev);
|
|
|
|
ev->event = strdup(e->event + 1);
|
|
|
|
ev->t0 = t;
|
|
|
|
ev->n = eina_list_count(stack) - 1;
|
|
|
|
ev->slot = slot;
|
|
|
|
if ((ev->n + 1) > h) h = ev->n + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (e->event[0] == '-')
|
|
|
|
{
|
|
|
|
l = eina_list_last(stack);
|
|
|
|
if (l)
|
|
|
|
{
|
|
|
|
ev = l->data;
|
|
|
|
ev->t1 = t;
|
|
|
|
if (_can_see(t0, t1, tmin, ev->t0, ev->t1))
|
|
|
|
_add_log_event(inf, ev);
|
|
|
|
else
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
stack = eina_list_remove_list(stack, l);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
}
|
|
|
|
else if (e->event[0] == '!')
|
|
|
|
{
|
|
|
|
ev = calloc(1, sizeof(Event));
|
|
|
|
if (ev)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
ev->src = e;
|
|
|
|
ev->event = strdup(e->event + 1);
|
|
|
|
ev->t0 = t;
|
|
|
|
ev->t1 = -1.0;
|
|
|
|
ev->n = 0;
|
|
|
|
ev->slot = -1;
|
|
|
|
if (_can_see(t0, t1, tmin, ev->t0, ev->t1))
|
|
|
|
_add_log_event(inf, ev);
|
|
|
|
else
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
else if (e->event[0] == '*')
|
|
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
t = evlog->last_timestamp - evlog->first_timestamp;
|
|
|
|
EINA_LIST_FREE(stack, ev)
|
|
|
|
{
|
|
|
|
ev->t1 = t;
|
|
|
|
if (_can_see(t0, t1, tmin, ev->t0, ev->t1))
|
|
|
|
_add_log_event(inf, ev);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_fill_event_clean(Inf *inf, double t0, double t1, double tmin)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Event *ev;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(inf->objs, l, ev)
|
|
|
|
{
|
|
|
|
if (_can_see(t0, t1, tmin, ev->t0, ev->t1))
|
|
|
|
{
|
|
|
|
if (ev->nuke)
|
|
|
|
{
|
|
|
|
inf->update.remobjs = eina_list_remove(inf->update.remobjs, ev);
|
|
|
|
ev->nuke = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!ev->nuke)
|
|
|
|
{
|
|
|
|
inf->update.remobjs = eina_list_append(inf->update.remobjs, ev);
|
|
|
|
ev->nuke = 1;
|
|
|
|
}
|
|
|
|
}
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-10-15 20:25:02 -07:00
|
|
|
_fill_log_table(Evas_Object *win, Evas_Object *tb, Evlog *evlog, Evas_Object *zoom)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Inf *inf = evas_object_data_get(zoom, "inf");
|
|
|
|
Evas_Object *o;
|
|
|
|
char buf[256];
|
|
|
|
int i, y = 0;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
o = elm_label_add(win);
|
|
|
|
elm_object_text_set(o, "<b>STATES</b>");
|
|
|
|
evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, 0.0);
|
|
|
|
evas_object_size_hint_align_set(o, EVAS_HINT_FILL, 0.5);
|
|
|
|
elm_table_pack(tb, o, 0, y, 1, 1);
|
|
|
|
evas_object_show(o);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
o = _create_log_states(win, evlog, zoom);
|
|
|
|
inf->grid.state = o;
|
|
|
|
evas_object_size_hint_weight_set(o, 0.0, 0.0);
|
|
|
|
evas_object_size_hint_align_set(o, EVAS_HINT_FILL, 0.5);
|
|
|
|
elm_table_pack(tb, o, 2, y++, 1, 1);
|
|
|
|
evas_object_show(o);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
inf->grid.thread = calloc(1, evlog->thread_num * sizeof(Evas_Object *));
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
for (i = 0; i < evlog->thread_num; i++)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "<b>%i</b>", i + 1);
|
|
|
|
|
|
|
|
o = elm_label_add(win);
|
|
|
|
elm_object_text_set(o, buf);
|
|
|
|
evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, 0.0);
|
|
|
|
evas_object_size_hint_align_set(o, EVAS_HINT_FILL, 0.5);
|
|
|
|
elm_table_pack(tb, o, 0, y, 1, 1);
|
|
|
|
evas_object_show(o);
|
|
|
|
|
|
|
|
o = _create_log_thread(win, evlog, &(evlog->threads[i]), i ,zoom);
|
|
|
|
inf->grid.thread[i] = o;
|
|
|
|
evas_object_size_hint_weight_set(o, 0.0, 0.0);
|
|
|
|
evas_object_size_hint_align_set(o, EVAS_HINT_FILL, 0.5);
|
|
|
|
elm_table_pack(tb, o, 2, y++, 1, 1);
|
|
|
|
evas_object_show(o);
|
|
|
|
}
|
|
|
|
|
|
|
|
o = elm_separator_add(win);
|
|
|
|
evas_object_size_hint_weight_set(o, 0.0, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(o, 0.5, EVAS_HINT_FILL);
|
|
|
|
elm_table_pack(tb, o, 1, 0, 1, y);
|
|
|
|
evas_object_show(o);
|
|
|
|
|
|
|
|
o = elm_grid_add(win);
|
|
|
|
inf->grid.over = o;
|
|
|
|
evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(o, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
|
|
|
elm_grid_size_set(o, (evlog->last_timestamp - evlog->first_timestamp) * RES, 1);
|
|
|
|
elm_table_pack(tb, o, 2, 0, 1, y);
|
|
|
|
evas_object_show(o);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_fill_blocking(void *data, Ecore_Thread *thread)
|
|
|
|
{
|
|
|
|
Inf *inf = data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
_fill_event_clean(inf,
|
|
|
|
inf->update.t0 - inf->evlog->first_timestamp,
|
|
|
|
inf->update.t1 - inf->evlog->first_timestamp,
|
|
|
|
inf->update.tmin);
|
|
|
|
|
|
|
|
_fill_log_states(inf, inf->evlog,
|
|
|
|
inf->update.t0 - inf->evlog->first_timestamp,
|
|
|
|
inf->update.t1 - inf->evlog->first_timestamp,
|
|
|
|
inf->update.tmin);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
for (i = 0; i < inf->evlog->thread_num; i++)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
_fill_log_thread(inf, inf->evlog, &(inf->evlog->threads[i]), i + 1,
|
|
|
|
inf->update.t0 - inf->evlog->first_timestamp,
|
|
|
|
inf->update.t1 - inf->evlog->first_timestamp,
|
|
|
|
inf->update.tmin);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_add_log_state_object(Evas_Object *win, Evas_Object *grid, Event *ev)
|
|
|
|
{
|
|
|
|
Evas_Object *o, *oe;
|
|
|
|
int col[4] = {255, 255, 255, 255}, i;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
o = elm_layout_add(win);
|
|
|
|
oe = elm_layout_edje_get(o);
|
|
|
|
elm_layout_file_set(o, "./evlog.edj", "state");
|
|
|
|
i = 0;
|
|
|
|
for (s = ev->event; *s; s++)
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
col[i % 3] ^= *s;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
edje_object_color_class_set(oe, "state",
|
|
|
|
col[0] / 2, col[1] / 2, col[2] / 2, col[3],
|
|
|
|
255, 255, 255, 255,
|
|
|
|
255, 255, 255, 255);
|
|
|
|
edje_object_part_text_set(oe, "text", ev->event);
|
|
|
|
elm_grid_pack(grid, o, ev->t0 * RES, ev->n, (ev->t1 - ev->t0) * RES, 1);
|
|
|
|
elm_object_tooltip_text_set(o, ev->event);
|
|
|
|
evas_object_show(o);
|
|
|
|
return o;
|
|
|
|
}
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
static Evas_Object *
|
|
|
|
_add_log_event_object(Evas_Object *win, Evas_Object *grid, Event *ev)
|
|
|
|
{
|
|
|
|
Evas_Object *o, *oe;
|
|
|
|
int col[4] = {255, 255, 255, 255}, i;
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
o = elm_layout_add(win);
|
|
|
|
oe = elm_layout_edje_get(o);
|
|
|
|
elm_layout_file_set(o, "./evlog.edj", "range");
|
|
|
|
i = 0;
|
|
|
|
for (s = ev->event; *s; s++)
|
|
|
|
{
|
|
|
|
col[i % 3] ^= *s;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
edje_object_color_class_set(oe, "range",
|
|
|
|
col[0] / 2, col[1] / 2, col[2] / 2, col[3],
|
|
|
|
255, 255, 255, 255,
|
|
|
|
255, 255, 255, 255);
|
|
|
|
edje_object_part_text_set(oe, "text", ev->event);
|
|
|
|
elm_grid_pack(grid, o, ev->t0 * RES, ev->n, (ev->t1 - ev->t0) * RES, 1);
|
|
|
|
elm_object_tooltip_text_set(o, ev->event);
|
|
|
|
evas_object_show(o);
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_add_log_frame_object(Evas_Object *win, Evas_Object *grid, Event *ev)
|
|
|
|
{
|
|
|
|
Evas_Object *o, *oe;
|
|
|
|
|
|
|
|
o = elm_layout_add(win);
|
|
|
|
oe = elm_layout_edje_get(o);
|
|
|
|
elm_layout_file_set(o, "./evlog.edj", "frame");
|
|
|
|
elm_grid_pack(grid, o, ev->t0 * RES, ev->n, (ev->t1 - ev->t0) * RES, 1);
|
|
|
|
elm_object_tooltip_text_set(o, ev->event);
|
|
|
|
evas_object_show(o);
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_fill_end(void *data, Ecore_Thread *thread)
|
|
|
|
{
|
|
|
|
Inf *inf = data;
|
|
|
|
Event *ev;
|
|
|
|
Evas_Object *o;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
inf->update.thread = NULL;
|
|
|
|
EINA_LIST_FOREACH(inf->objs, l, ev)
|
|
|
|
{
|
|
|
|
if ((!ev->obj) && (!ev->nuke))
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
if (ev->slot == 0) // state
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
o = _add_log_state_object(inf->win,
|
|
|
|
inf->grid.state,
|
|
|
|
ev);
|
|
|
|
ev->obj = o;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
else if (ev->slot > 0) // thread
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
o = _add_log_event_object(inf->win,
|
|
|
|
inf->grid.thread[ev->slot - 1],
|
|
|
|
ev);
|
|
|
|
ev->obj = o;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
else if (ev->slot == -1) // frames
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
if (!strcmp(ev->event, "FRAME"))
|
2015-07-02 05:02:04 -07:00
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
o = _add_log_frame_object(inf->win,
|
|
|
|
inf->grid.over,
|
|
|
|
ev);
|
|
|
|
ev->obj = o;
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-10-15 20:25:02 -07:00
|
|
|
EINA_LIST_FREE(inf->update.remobjs, ev)
|
|
|
|
{
|
|
|
|
inf->objs = eina_list_remove(inf->objs, ev);
|
|
|
|
if (ev->obj) evas_object_del(ev->obj);
|
|
|
|
free(ev->event);
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
if (inf->update.redo)
|
|
|
|
{
|
|
|
|
inf->update.redo = EINA_FALSE;
|
|
|
|
_fill_begin(inf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_fill_cancel(void *data, Ecore_Thread *thread)
|
|
|
|
{
|
|
|
|
Inf *inf = data;
|
|
|
|
inf->update.thread = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_fill_begin(Inf *inf)
|
|
|
|
{
|
|
|
|
Evas_Coord x, w, wx, ww;
|
|
|
|
double t, t0, t1;
|
|
|
|
Evas_Coord gw;
|
|
|
|
|
|
|
|
if (inf->update.thread)
|
|
|
|
{
|
|
|
|
inf->update.redo = EINA_TRUE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
elm_grid_size_get(inf->grid.state, &gw, NULL);
|
|
|
|
evas_object_geometry_get(inf->grid.state, &x, NULL, &w, NULL);
|
|
|
|
evas_output_viewport_get(evas_object_evas_get(inf->grid.state),
|
|
|
|
&wx, NULL, &ww, NULL);
|
|
|
|
if (ww < 1) ww = 1;
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
if (w < ww) w = ww;
|
|
|
|
if (gw < 1) gw = 1;
|
|
|
|
|
|
|
|
t0 = inf->evlog->first_timestamp;
|
|
|
|
t1 = inf->evlog->last_timestamp;
|
|
|
|
|
|
|
|
inf->update.tmin = (1.0 * (double)gw) / ((double)w * RES);
|
|
|
|
|
|
|
|
wx -= 100;
|
|
|
|
ww += 200;
|
|
|
|
|
|
|
|
t = ((t1 - t0) * (double)ww) / ((double)w);
|
|
|
|
t0 = ((wx - x) * (t1 - t0)) / ((double)w);
|
|
|
|
if (t0 < 0.0) t0 = 0.0;
|
|
|
|
inf->update.t0 = t0 + inf->evlog->first_timestamp;
|
|
|
|
inf->update.t1 = inf->update.t0 + t;
|
|
|
|
inf->update.thread = ecore_thread_run(_cb_fill_blocking,
|
|
|
|
_cb_fill_end,
|
|
|
|
_cb_fill_cancel,
|
|
|
|
inf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_fill_job(void *data)
|
|
|
|
{
|
|
|
|
Inf *inf = evas_object_data_get(data, "inf");
|
|
|
|
inf->update.job = NULL;
|
|
|
|
_fill_begin(inf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_fill_update(Evas_Object *zoom)
|
|
|
|
{
|
|
|
|
Inf *inf = evas_object_data_get(zoom, "inf");
|
|
|
|
if (inf->update.job) ecore_job_del(inf->update.job);
|
|
|
|
inf->update.job = ecore_job_add(_cb_fill_job, zoom);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_zoom(void *data, Evas_Object *obj, void *info)
|
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Inf *inf = evas_object_data_get(data, "inf");
|
|
|
|
Evas_Coord w = 0, h = 1;
|
|
|
|
evas_object_size_hint_min_get(inf->grid.state, &w, &h);
|
|
|
|
if (w < 1) w = 1;
|
|
|
|
double len = inf->evlog->last_timestamp - inf->evlog->first_timestamp;
|
|
|
|
double res = elm_slider_value_get(obj);
|
|
|
|
Evas_Coord sx, sy, sw, sh;
|
|
|
|
elm_scroller_region_get(inf->scroller, &sx, &sy, &sw, &sh);
|
|
|
|
res = res * res;
|
|
|
|
evas_object_size_hint_min_set(inf->grid.state, len * res, h);
|
|
|
|
double snx = ((double)(sx + (sw / 2)) * (len * res)) / (double)w;
|
|
|
|
double snw = ((double)(sw) * (len * res)) / (double)w;
|
|
|
|
elm_scroller_region_show(inf->scroller, snx - (snw / 2), sy, snw, sh);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_move(void *data, Evas *e, Evas_Object *obj, void *info)
|
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
_fill_update(data);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_resize(void *data, Evas *e, Evas_Object *obj, void *info)
|
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
_fill_update(data);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cb_sc_resize(void *data, Evas *e, Evas_Object *obj, void *info)
|
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
_fill_update(data);
|
2015-07-02 05:02:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
evlog_view_add(Evas_Object *win, Evlog *evlog, Evas_Object *zoom)
|
|
|
|
{
|
2015-10-15 20:25:02 -07:00
|
|
|
Inf *inf = evas_object_data_get(zoom, "inf");
|
2015-07-02 05:02:04 -07:00
|
|
|
Evas_Object *o;
|
2015-10-15 20:25:02 -07:00
|
|
|
Evas_Object *sc, *tb;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
sc = o = elm_scroller_add(win);
|
2015-10-15 20:25:02 -07:00
|
|
|
inf->scroller = o;
|
|
|
|
evas_object_event_callback_add(o, EVAS_CALLBACK_RESIZE, _cb_sc_resize, zoom);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
tb = o = elm_table_add(win);
|
2015-10-15 20:25:02 -07:00
|
|
|
evas_object_event_callback_add(o, EVAS_CALLBACK_MOVE, _cb_move, zoom);
|
|
|
|
evas_object_event_callback_add(o, EVAS_CALLBACK_RESIZE, _cb_resize, zoom);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
_fill_log_table(win, tb, evlog, zoom);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
elm_object_content_set(sc, tb);
|
|
|
|
evas_object_show(tb);
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
evas_object_smart_callback_add(zoom, "changed", _cb_zoom, zoom);
|
2015-07-02 05:02:04 -07:00
|
|
|
return sc;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI_MAIN int
|
|
|
|
elm_main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
Evlog *evl;
|
|
|
|
Evas_Object *o;
|
|
|
|
Evas_Object *box;
|
2015-10-15 20:25:02 -07:00
|
|
|
Inf *inf;
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
if (argc < 2) return -1;
|
|
|
|
evl = evlog_new(argv[1]);
|
|
|
|
if (!evl) return -1;
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
inf = calloc(1, sizeof(Inf));
|
|
|
|
inf->evlog = evl;
|
|
|
|
|
2015-07-02 05:02:04 -07:00
|
|
|
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
|
|
|
|
|
|
|
|
win = elm_win_util_standard_add("evlog", "Event Log");
|
2015-10-15 20:25:02 -07:00
|
|
|
inf->win = win;
|
2015-07-02 05:02:04 -07:00
|
|
|
elm_win_autodel_set(win, EINA_TRUE);
|
2015-10-15 20:25:02 -07:00
|
|
|
evas_object_data_set(win, "inf", inf);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
box = o = elm_box_add(win);
|
|
|
|
evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
elm_box_horizontal_set(o, EINA_FALSE);
|
|
|
|
elm_win_resize_object_add(win, o);
|
|
|
|
evas_object_show(o);
|
|
|
|
|
|
|
|
zoom_slider = o = elm_slider_add(win);
|
2015-10-15 20:25:02 -07:00
|
|
|
evas_object_data_set(o, "inf", inf);
|
|
|
|
elm_slider_min_max_set(o, 1.0, 500.0);
|
2015-07-02 05:02:04 -07:00
|
|
|
elm_slider_step_set(o, 0.1);
|
2015-10-15 20:25:02 -07:00
|
|
|
elm_slider_value_set(o, 20.0);
|
2015-07-02 05:02:04 -07:00
|
|
|
elm_object_text_set(o, "Zoom");
|
|
|
|
elm_slider_unit_format_set(o, "%1.1f");
|
|
|
|
evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, 0.0);
|
|
|
|
evas_object_size_hint_align_set(o, EVAS_HINT_FILL, 0.0);
|
|
|
|
elm_box_pack_end(box, o);
|
|
|
|
evas_object_show(o);
|
|
|
|
|
|
|
|
o = evlog_view_add(win, evl, zoom_slider);
|
|
|
|
evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(o, EVAS_HINT_FILL, EVAS_HINT_FILL);
|
|
|
|
elm_box_pack_end(box, o);
|
|
|
|
evas_object_show(o);
|
|
|
|
|
2015-10-15 20:25:02 -07:00
|
|
|
evas_object_resize(win, 620, 400);
|
2015-07-02 05:02:04 -07:00
|
|
|
|
|
|
|
evas_object_show(win);
|
|
|
|
elm_run();
|
|
|
|
evlog_free(evl);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
ELM_MAIN()
|