enlightenment/clouseau
enlightenment
/
clouseau
7
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

clouseau: Adopted ecore_con_eet interface. This is a whole-new clouseau 

utilizing the new ecore_con_eet API. Clouseau looks the same as before, changed communication handling.

Signed-off-by: Aharon Hillel <a.hillel@samsung.com>

SVN revision: 79825
This commit is contained in:
Aharon Hillel 2012-11-29 11:09:10 +00:00 committed by Daniel Zaoui
parent 6cdcdb1b2e
commit 65e9f49ccd
5 changed files with 745 additions and 983 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

562
src/bin/clouseau.c
View File

@ -1,6 +1,6 @@
#include <Elementary_Cursor.h>
#include "Clouseau.h"
#include <Ecore_Ipc.h>
#include <Ecore_Con_Eet.h>
#include "clouseau_private.h"
@ -12,8 +12,8 @@
struct _app_data_st
{
Variant_st *app; /* app->data is (app_info_st *) */
Variant_st *td; /* tree->data is (tree_data_st *) */
app_info_st *app;
tree_data_st *td;
};
typedef struct _app_data_st app_data_st;
@ -59,7 +59,7 @@ static Eina_List *bmp_req = NULL; /* List of (bmp_node *) */
static Elm_Genlist_Item_Class itc;
static Eina_Bool list_show_clippers = EINA_TRUE, list_show_hidden = EINA_TRUE;
static Eina_Bool do_highlight = EINA_TRUE;
static Ecore_Ipc_Server *svr = NULL;
static Ecore_Con_Reply *eet_svr = NULL;
static Eina_Bool _add_callback_called = EINA_FALSE;
static void _cancel_bt_clicked(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED);
static void _ofl_bt_clicked(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED);
@ -76,7 +76,7 @@ _titlebar_string_set(gui_elements *g, Eina_Bool online)
}
else
{
char *str = malloc(strlen(CLIENT_NAME) + 32);
char *str = malloc(strlen(CLIENT_NAME) + strlen(" - Offline") + 32);
sprintf(str, "%s - Offline", CLIENT_NAME);
elm_win_title_set(g->win, str);
free(str);
@ -84,30 +84,15 @@ _titlebar_string_set(gui_elements *g, Eina_Bool online)
}
Eina_Bool
_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
_add(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED Ecore_Con_Server *conn)
{
Ecore_Ipc_Event_Server_Add *ev = event;
void *p;
int size = 0;
_add_callback_called = EINA_TRUE;
ecore_ipc_server_data_size_max_set(ev->server, -1);
if (svr)
{
eet_svr = reply;
connect_st t = { getpid(), __FILE__ };
p = clouseau_data_packet_compose(CLOUSEAU_GUI_CLIENT_CONNECT,
&t, sizeof(t), &size, NULL, 0);
if (p)
{
ecore_ipc_server_send(ev->server, 0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_server_flush(ev->server);
free(p);
}
ecore_con_eet_send(reply, CLOUSEAU_GUI_CLIENT_CONNECT_STR, &t);
_titlebar_string_set(gui, EINA_TRUE);
}
return ECORE_CALLBACK_RENEW;
}
@ -176,22 +161,21 @@ _work_offline_popup(void)
}
Eina_Bool
_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
_del(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
Ecore_Con_Server *conn)
{
Ecore_Ipc_Event_Server_Del *ev = event;
if ((!_add_callback_called) || (!ev->server))
if ((!_add_callback_called) || (!eet_svr))
{ /* if initial connection with daemon failed - exit */
ecore_ipc_server_del(ev->server);
svr = NULL; /* Global svr var */
ecore_con_server_del(conn);
eet_svr = NULL; /* Global svr var */
_work_offline_popup();
return ECORE_CALLBACK_RENEW;
}
printf("Lost server with ip %s!\n", ecore_ipc_server_ip_get(ev->server));
printf("Lost server with ip <%s>!\n", ecore_con_server_ip_get(conn));
ecore_ipc_server_del(ev->server);
svr = NULL; /* Global svr var */
ecore_con_server_del(conn);
eet_svr = NULL; /* Global svr var */
_show_gui(gui, EINA_TRUE);
return ECORE_CALLBACK_RENEW;
@ -269,25 +253,24 @@ static void
_close_app_views(app_info_st *app, Eina_Bool clr)
{ /* Close any open-views if this app */
Eina_List *l;
Variant_st *view;
bmp_info_st *view;
EINA_LIST_FOREACH(app->view, l, view)
{
bmp_info_st *b = view->data;
if (b->win)
evas_object_del(b->win);
if (view->win)
evas_object_del(view->win);
if (b->bt)
elm_object_disabled_set(b->bt, EINA_FALSE);
if (view->bt)
elm_object_disabled_set(view->bt, EINA_FALSE);
b->win = b->bt = NULL;
view->win = view->bt = NULL;
}
if (clr)
{ /* These are cleared when app data is reloaded */
EINA_LIST_FREE(app->view, view)
{ /* Free memory allocated to show any app screens */
clouseau_bmp_blob_free(view->data);
clouseau_data_variant_free(view);
clouseau_bmp_blob_free(view);
free(view);
}
app->view = NULL;
@ -304,14 +287,14 @@ _set_selected_app(void *data, Evas_Object *pobj,
gui->gl_it = NULL;
if (gui->sel_app)
_close_app_views(gui->sel_app->app->data, EINA_FALSE);
_close_app_views(gui->sel_app->app, EINA_FALSE);
if (st)
{
if (!svr)
if (!eet_svr)
{ /* Got TREE_DATA from file, update this immidately */
gui->sel_app = st;
char *str = _app_name_get(st->app->data);
char *str = _app_name_get(st->app);
elm_object_text_set(pobj, str);
free(str);
_load_list(gui);
@ -321,7 +304,7 @@ _set_selected_app(void *data, Evas_Object *pobj,
if (gui->sel_app != st)
{ /* Reload only of selected some other app */
gui->sel_app = st;
char *str = _app_name_get(st->app->data);
char *str = _app_name_get(st->app);
elm_object_text_set(pobj, str);
free(str);
@ -338,7 +321,7 @@ _set_selected_app(void *data, Evas_Object *pobj,
gui->sel_app = NULL;
}
if (svr)
if (eet_svr)
{ /* Enable/Disable buttons only if we are online */
elm_object_disabled_set(gui->bt_load, (gui->sel_app == NULL));
elm_object_disabled_set(gui->bt_save, (gui->sel_app == NULL));
@ -349,7 +332,7 @@ static int
_app_ptr_cmp(const void *d1, const void *d2)
{
const app_data_st *info = d1;
app_info_st *app = info->app->data;
app_info_st *app = info->app;
return ((app->ptr) - (unsigned long long) (uintptr_t) d2);
}
@ -357,7 +340,7 @@ _app_ptr_cmp(const void *d1, const void *d2)
static void
_add_app_to_dd_list(Evas_Object *dd_list, app_data_st *st)
{ /* Add app to Drop Down List */
char *str = _app_name_get(st->app->data);
char *str = _app_name_get(st->app);
elm_hoversel_item_add(dd_list, str, NULL, ELM_ICON_NONE,
_set_selected_app, st);
@ -367,53 +350,48 @@ _add_app_to_dd_list(Evas_Object *dd_list, app_data_st *st)
static int
_bmp_object_ptr_cmp(const void *d1, const void *d2)
{ /* Comparison according to Evas ptr of BMP struct */
const Variant_st *info = d1;
bmp_info_st *bmp = info->data;
const bmp_info_st *bmp = d1;
return ((bmp->object) - (unsigned long long) (uintptr_t) d2);
}
static int
_bmp_app_ptr_cmp(const void *d1, const void *d2)
{ /* Comparison according to app ptr of BMP struct */
const Variant_st *info = d1;
bmp_info_st *bmp = info->data;
const bmp_info_st *bmp = d1;
return ((bmp->app) - (unsigned long long) (uintptr_t) d2);
}
static Eina_List *
_remove_bmp(Eina_List *view, void *ptr)
{ /* Remove app bitmap from bitmaps list */
Variant_st *v = (Variant_st *)
bmp_info_st *st = (bmp_info_st *)
eina_list_search_unsorted(view, _bmp_app_ptr_cmp,
(void *) (uintptr_t) ptr);
if (v)
if (st)
{
bmp_info_st *st = v->data;
if (st->win)
evas_object_del(st->win);
if (st->bmp)
free(st->bmp);
clouseau_data_variant_free(v);
return eina_list_remove(view, v);
free(st);
return eina_list_remove(view, st);
}
return view;
}
static app_data_st *
_add_app(gui_elements *g, Variant_st *v)
_add_app(gui_elements *g, app_info_st *app)
{
app_data_st *st;
st = malloc(sizeof(app_data_st));
if (!st) return NULL;
st->app = v;
st->app = app;
st->td = NULL; /* Will get this on TREE_DATA message */
apps = eina_list_append(apps, st);
@ -423,48 +401,43 @@ _add_app(gui_elements *g, Variant_st *v)
}
static void
_free_app_tree_data(Variant_st *td)
_free_app_tree_data(tree_data_st *ftd)
{
tree_data_st *ftd;
if (!td) return ;
if (!ftd) return;
ftd = td->data;
clouseau_data_tree_free(ftd->tree);
clouseau_data_variant_free(td);
free(ftd);
}
static void
_free_app(app_data_st *st)
{
Variant_st *view;
app_info_st *app = st->app->data;
bmp_info_st *view;
app_info_st *app = st->app;
if (app->file)
free(app->file);
EINA_LIST_FREE(app->view, view)
{ /* Free memory allocated to show any app screens */
bmp_info_st *b = view->data;
if (b->win)
evas_object_del(b->win);
if (view->win)
evas_object_del(view->win);
if (b->bmp)
free(b->bmp);
if (view->bmp)
free(view->bmp);
clouseau_data_variant_free(view);
free(view);
}
clouseau_data_variant_free(st->app);
_free_app_tree_data(st->td);
free(app);
free(st);
}
static void
_remove_app(gui_elements *g, Variant_st *v)
{
app_closed_st *app = v->data;
/* Handle the case that NO app is selected, set sel_app to NULL */
app_info_st *sel_app = (g->sel_app) ? g->sel_app->app->data : NULL;
_remove_app(gui_elements *g, app_closed_st *app)
{ /* Handle the case that NO app is selected, set sel_app to NULL */
app_info_st *sel_app = (g->sel_app) ? g->sel_app->app: NULL;
app_data_st *st = (app_data_st *)
eina_list_search_unsorted(apps, _app_ptr_cmp,
(void *) (uintptr_t) app->ptr);
@ -474,7 +447,7 @@ _remove_app(gui_elements *g, Variant_st *v)
_set_selected_app(NULL, g->dd_list, NULL);
if (st)
{ /* Remove from list and free all variants */
{ /* Remove from list and free all app info */
Eina_List *l;
apps = eina_list_remove(apps, st);
_free_app(st);
@ -486,46 +459,15 @@ _remove_app(gui_elements *g, Variant_st *v)
EINA_LIST_FOREACH(apps, l , st)
_add_app_to_dd_list(g->dd_list, st);
}
clouseau_data_variant_free(v);
}
static void
_update_tree_offline(gui_elements *g, Variant_st *v)
_update_tree_offline(gui_elements *g, tree_data_st *td)
{
tree_data_st *td = v->data;
elm_genlist_clear(g->gl);
_load_gui_with_list(g, td->tree);
}
static void
_update_tree(gui_elements *g, Variant_st *v)
{ /* Update Tree for app, then update GUI if its displayed */
tree_data_st *td = v->data;
app_info_st *selected = g->sel_app->app->data;
/* Update only if tree is from APP on our list */
app_data_st *st = (app_data_st *)
eina_list_search_unsorted(apps, _app_ptr_cmp,
(void *) (uintptr_t) td->app);
if (st)
{ /* Free app TREE_DATA then set ptr to new data */
_free_app_tree_data(st->td);
st->td = v;
if (selected->ptr == td->app)
{ /* Update GUI only if TREE_DATA is from SELECTED app */
elm_genlist_clear(g->gl);
_load_gui_with_list(g, td->tree);
}
}
else
{ /* Happens when TREE_DATA of app that already closed has arrived */
_free_app_tree_data(v); /* Dispose unused info */
}
}
static int
_bmp_node_cmp(const void *d1, const void *d2)
{ /* Compare accoring to Evas ptr */
@ -566,66 +508,6 @@ _get_bmp_node(bmp_info_st *st, app_info_st *app)
return NULL;
}
static void
_add_bmp(gui_elements *g EINA_UNUSED, Variant_st *v)
{ /* Remove bmp if exists (according to obj-ptr), then add the new one */
bmp_info_st *st = v->data;
st->zoom_val = 1.0; /* Init zoom value */
app_data_st *app = (app_data_st *)
eina_list_search_unsorted(apps, _app_ptr_cmp,
(void *) (uintptr_t) st->app);
/* Check for relevant bmp req in the bmp_req list */
bmp_node *nd = _get_bmp_node(st, app->app->data);
if (!st->bmp)
{ /* We consider a case out request will be answered with empty bmp
this may happen if we have a sub-window of app
(like checks in elementary test)
if the user closed it just as we send our BMP_REQ
this Evas is no longer valid and we get NULL ptr for BMP.
This code ignores this case. */
elm_progressbar_pulse(g->pb, EINA_FALSE);
evas_object_hide(g->pb);
clouseau_data_variant_free(v);
/* Make refresh button display: screenshot NOT available */
if (nd)
_set_button(g->win, nd->bt,
SCREENSHOT_MISSING,
"Screenshot not available", EINA_TRUE);
return;
}
if (app && nd)
{ /* Remove app bmp data if exists, then update */
elm_progressbar_pulse(g->pb, EINA_FALSE);
evas_object_hide(g->pb);
app_info_st *info = app->app->data;
info->view = _remove_bmp(info->view,
(void *) (uintptr_t) (st->object));
info->view = eina_list_append(info->view, v);
/* Now we need to update refresh button, make it open-window */
_set_button(g->win, nd->bt,
SHOW_SCREENSHOT,
"Show App Screenshot", EINA_FALSE);
bmp_req = eina_list_remove(bmp_req, nd);
free(nd);
}
else
{ /* Dispose bmp info if app no longer in the list of apps */
/* or the bmp_info is no longer relevant */
if (st->bmp)
free(st->bmp);
clouseau_data_variant_free(v);
}
}
static void
clouseau_make_lines(bmp_info_st *st, Evas_Coord xx, Evas_Coord yy)
{ /* and no, we are NOT talking about WHITE lines */
@ -719,6 +601,7 @@ _app_win_del(void *data,
Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{ /* when closeing view, set view ptr to NULL, and enable open button */
bmp_info_st *st = data;
clouseau_lines_free(st);
elm_object_disabled_set(st->bt, EINA_FALSE);
evas_object_event_callback_del(st->o, EVAS_CALLBACK_MOUSE_MOVE,
_mouse_move);
@ -818,6 +701,7 @@ _open_app_window(bmp_info_st *st, Evas_Object *bt, Clouseau_Tree_Item *treeit)
char s_bar[128];
char *win_name = malloc(strlen(treeit->name) + strlen(SHOT_HEADER) + 1);
st->zoom_val = 1.0; /* Init zoom value */
st->bt = bt;
st->win = elm_win_add(NULL, "win", ELM_WIN_BASIC);
sprintf(win_name, "%s%s", treeit->name, SHOT_HEADER);
@ -938,34 +822,24 @@ _open_app_window(bmp_info_st *st, Evas_Object *bt, Clouseau_Tree_Item *treeit)
static void
_show_app_window(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{ /* Open window with currnent bmp, or download it if missing */
app_info_st *st = gui->sel_app->app->data;
app_info_st *st = gui->sel_app->app;
Clouseau_Tree_Item *treeit = data;
/* First search app->view list if already have the window bmp */
Variant_st *v = (Variant_st *)
bmp_info_st *bmp = (bmp_info_st *)
eina_list_search_unsorted(st->view, _bmp_object_ptr_cmp,
(void *) (uintptr_t) treeit->ptr);
if (v)
return _open_app_window(v->data, obj, data);
if (bmp)
return _open_app_window(bmp, obj, data);
/* Need to issue BMP_REQ */
if (svr)
if (eet_svr)
{
int size = 0;
bmp_req_st t = { (unsigned long long) (uintptr_t) NULL,
(unsigned long long) (uintptr_t) st->ptr,
(unsigned long long) (uintptr_t) treeit->ptr, st->refresh_ctr };
void *p = clouseau_data_packet_compose(CLOUSEAU_BMP_REQ,
&t, sizeof(t), &size, NULL, 0);
if (p)
{
ecore_ipc_server_send(svr,
0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_server_flush(svr);
free(p);
ecore_con_eet_send(eet_svr, CLOUSEAU_BMP_REQ_STR, &t);
elm_object_disabled_set(obj, EINA_TRUE);
elm_progressbar_pulse(gui->pb, EINA_TRUE);
evas_object_show(gui->pb);
@ -976,49 +850,118 @@ _show_app_window(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
b_node->bt = obj; /* Button of BMP_REQ */
bmp_req = eina_list_append(bmp_req, b_node);
}
}
else /* Disable button if we lost server */
_set_button(gui->win, obj,
SCREENSHOT_MISSING,
"Screenshot not available", EINA_TRUE);
}
Eina_Bool
_data(void *data, int type EINA_UNUSED, void *event)
/* START - Callbacks to handle messages from daemon */
void
_app_closed_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{
Ecore_Ipc_Event_Server_Data *ev = event;
Variant_st *v;
_remove_app(gui, value);
}
v = clouseau_data_packet_info_get(ev->data, ev->size);
if (!v) return ECORE_CALLBACK_RENEW;
void
_app_add_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{
_add_app(gui, value);
}
switch (clouseau_data_packet_mapping_type_get(v->type))
{
case CLOUSEAU_APP_ADD: /* Add info to list of APPs */
_add_app(data, v); /* v->data is (app_info_st *) */
break;
void
_tree_data_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* Update Tree for app, then update GUI if its displayed */
tree_data_st *td = value;
app_info_st *selected = gui->sel_app->app;
case CLOUSEAU_APP_CLOSED: /* Remove and free APP info */
_remove_app(data, v); /* v->data is (app_closed_st *) */
break;
/* Update only if tree is from APP on our list */
app_data_st *st = (app_data_st *)
eina_list_search_unsorted(apps, _app_ptr_cmp,
(void *) (uintptr_t) td->app);
case CLOUSEAU_TREE_DATA: /* Update genlist with APP TREE info */
_update_tree(data, v); /* data is the gui pointer */
break; /* v->data is (tree_data_st *) */
if (st)
{ /* Free app TREE_DATA then set ptr to new data */
_free_app_tree_data(st->td);
st->td = value;
case CLOUSEAU_BMP_DATA: /* Contains a snapshot of canvas window */
{ /* v->data is (bmp_info_st *) */
_add_bmp(data, v); /* data is the gui pointer */
if (selected->ptr == td->app)
{ /* Update GUI only if TREE_DATA is from SELECTED app */
elm_genlist_clear(gui->gl);
_load_gui_with_list(gui, td->tree);
}
break;
}
else
{ /* Happens when TREE_DATA of app that already closed has arrived */
_free_app_tree_data(value);
}
}
default:
break;
void
_bmp_data_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
const char *protocol_name, EINA_UNUSED const char *section,
void *value, size_t length)
{ /* Remove bmp if exists (according to obj-ptr), then add the new one */
bmp_info_st *st = clouseau_data_packet_info_get(protocol_name,
value, length);
st->zoom_val = 1.0; /* Init zoom value */
app_data_st *app = (app_data_st *)
eina_list_search_unsorted(apps, _app_ptr_cmp,
(void *) (uintptr_t) st->app);
/* Check for relevant bmp req in the bmp_req list */
bmp_node *nd = _get_bmp_node(st, app->app);
if (!st->bmp)
{ /* We consider a case out request will be answered with empty bmp
this may happen if we have a sub-window of app
(like checks in elementary test)
if the user closed it just as we send our BMP_REQ
this Evas is no longer valid and we get NULL ptr for BMP.
This code ignores this case. */
elm_progressbar_pulse(gui->pb, EINA_FALSE);
evas_object_hide(gui->pb);
free(st);
/* Make refresh button display: screenshot NOT available */
if (nd)
_set_button(gui->win, nd->bt,
SCREENSHOT_MISSING,
"Screenshot not available", EINA_TRUE);
return;
}
/* variant_free(v) - freed when removed from app list */
if (app && nd)
{ /* Remove app bmp data if exists, then update */
elm_progressbar_pulse(gui->pb, EINA_FALSE);
evas_object_hide(gui->pb);
return ECORE_CALLBACK_RENEW;
app_info_st *info = app->app;
info->view = _remove_bmp(info->view,
(void *) (uintptr_t) (st->object));
info->view = eina_list_append(info->view, st);
/* Now we need to update refresh button, make it open-window */
_set_button(gui->win, nd->bt,
SHOW_SCREENSHOT,
"Show App Screenshot", EINA_FALSE);
bmp_req = eina_list_remove(bmp_req, nd);
free(nd);
}
else
{ /* Dispose bmp info if app no longer in the list of apps */
/* or the bmp_info is no longer relevant */
if (st->bmp)
free(st->bmp);
free(st);
}
}
static void
@ -1064,8 +1007,6 @@ gl_con_req(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_inf
elm_genlist_item_expanded_set(glit, EINA_FALSE);
}
static Evas_Object *
item_icon_get(void *data, Evas_Object *parent, const char *part)
{
@ -1079,15 +1020,15 @@ item_icon_get(void *data, Evas_Object *parent, const char *part)
Evas_Object *bt = elm_button_add(parent);
app_info_st *app = NULL;
if (gui->sel_app)
app = gui->sel_app->app->data;
app = gui->sel_app->app;
if (app)
{ /* match ptr with bmp->object ptr to find view */
Variant_st *v = (Variant_st *)
bmp_info_st *bmp = (bmp_info_st *)
eina_list_search_unsorted(app->view, _bmp_object_ptr_cmp,
(void *) (uintptr_t) treeit->ptr);
if (v)
if (bmp)
{ /* Set to "show view" if view exists */
_set_button(parent, bt,
SHOW_SCREENSHOT,
@ -1095,7 +1036,7 @@ item_icon_get(void *data, Evas_Object *parent, const char *part)
}
else
{ /* Set to Download or not available if offline */
if (svr)
if (eet_svr)
{
_set_button(parent, bt,
TAKE_SCREENSHOT,
@ -1200,15 +1141,17 @@ client_win_del(void *data EINA_UNUSED,
elm_exit(); /* exit the program's main loop that runs in elm_run() */
}
static Ecore_Ipc_Server *
static Eina_Bool
_connect_to_daemon(gui_elements *g)
{
if (svr && ecore_ipc_server_connected_get(svr))
return svr; /* Already connected */
if (eet_svr)
return EINA_TRUE;
int port = PORT;
char *address = LOCALHOST;
char *p_colon = NULL;
Ecore_Con_Server *server;
Ecore_Con_Eet *ece = NULL;
if (g->address && strlen(g->address))
{
@ -1223,28 +1166,44 @@ _connect_to_daemon(gui_elements *g)
port = atoi(p_colon+1);
}
svr = ecore_ipc_server_connect(ECORE_IPC_REMOTE_SYSTEM,
server = ecore_con_server_connect(ECORE_CON_REMOTE_TCP,
address, port, NULL);
if (p_colon)
*p_colon = ':';
if (!svr)
if (!server)
{
printf("could not connect to the server: %s\n", g->address);
return NULL;
return EINA_FALSE;
}
ecore_ipc_server_data_size_max_set(svr, -1);
/* TODO: ecore_con_server_data_size_max_set(server, -1); */
/* set event handler for server connect */
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_ADD, _add, g);
/* set event handler for server disconnect */
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DEL, _del, g);
/* set event handler for receiving server data */
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DATA, _data, g);
ece = ecore_con_eet_client_new(server);
if (!ece)
{
printf("could not connect to the server: %s\n", g->address);
return EINA_FALSE;
}
return svr;
clouseau_register_descs(ece);
/* Register callbacks for ecore_con_eet */
ecore_con_eet_server_connect_callback_add(ece, _add, NULL);
ecore_con_eet_server_disconnect_callback_add(ece, _del, NULL);
ecore_con_eet_data_callback_add(ece, CLOUSEAU_APP_CLOSED_STR,
_app_closed_cb, NULL);
ecore_con_eet_data_callback_add(ece, CLOUSEAU_APP_ADD_STR,
_app_add_cb, NULL);
ecore_con_eet_data_callback_add(ece, CLOUSEAU_TREE_DATA_STR,
_tree_data_cb, NULL);
/* At the moment our only raw-data packet is BMP info */
ecore_con_eet_raw_data_callback_add(ece, CLOUSEAU_BMP_DATA_STR,
_bmp_data_cb, NULL);
return EINA_TRUE;
}
static void
@ -1268,23 +1227,13 @@ _gl_selected(void *data, Evas_Object *pobj EINA_UNUSED, void *event_info)
return;
/* START - replacing libclouseau_highlight(obj); */
int size;
app_info_st *app = g->sel_app->app->data;
app_info_st *app = g->sel_app->app;
highlight_st st = { (unsigned long long) (uintptr_t) app->ptr,
treeit->ptr };
if (svr)
if (eet_svr)
{
void *p = clouseau_data_packet_compose(CLOUSEAU_HIGHLIGHT,
&st, sizeof(st), &size, NULL, 0);
if (p)
{
ecore_ipc_server_send(svr,
0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_server_flush(svr);
free(p);
}
ecore_con_eet_send(eet_svr, CLOUSEAU_HIGHLIGHT_STR, &st);
}
/* We also like to HIGHLIGHT on any app views that open (for offline) */
@ -1296,14 +1245,14 @@ _gl_selected(void *data, Evas_Object *pobj EINA_UNUSED, void *event_info)
while (prt);
Clouseau_Tree_Item *t = elm_object_item_data_get(parent);
Variant_st *v = eina_list_search_unsorted(app->view,
bmp_info_st *bmp = eina_list_search_unsorted(app->view,
_bmp_object_ptr_cmp,
(void*) (uintptr_t) t->ptr);
if (v)
if (bmp && bmp->win)
{ /* Third param gives evas surface when running offline */
clouseau_data_object_highlight((void*) (uintptr_t) treeit->ptr,
&treeit->info->evas_props, v->data);
&treeit->info->evas_props, bmp);
}
/* END - replacing clouseau_object_highlight(obj); */
}
@ -1318,8 +1267,8 @@ _load_list(gui_elements *g)
{
elm_genlist_clear(g->gl);
elm_genlist_clear(g->prop_list);
app_info_st *st = g->sel_app->app->data;
tree_data_st *td = (g->sel_app->td) ? g->sel_app->td->data: NULL;
app_info_st *st = g->sel_app->app;
tree_data_st *td = (g->sel_app->td) ? g->sel_app->td : NULL;
if (td)
{ /* Just show currnet tree we got */
@ -1327,7 +1276,7 @@ _load_list(gui_elements *g)
}
else
{ /* Ask for app info only if was not fetched */
if (!svr)
if (!eet_svr)
{
_update_tree_offline(g, g->sel_app->td);
return 0;
@ -1336,22 +1285,12 @@ _load_list(gui_elements *g)
if (eina_list_search_unsorted(apps, _app_ptr_cmp,
(void *) (uintptr_t) st->ptr))
{ /* do it only if app selected AND found in apps list */
int size;
data_req_st t = { (unsigned long long) (uintptr_t) NULL,
(unsigned long long) (uintptr_t) st->ptr };
void *p = clouseau_data_packet_compose(CLOUSEAU_DATA_REQ,
&t, sizeof(t), &size, NULL, 0);
if (p)
{
ecore_con_eet_send(eet_svr, CLOUSEAU_DATA_REQ_STR, &t);
elm_progressbar_pulse(g->pb, EINA_TRUE);
evas_object_show(g->pb);
ecore_ipc_server_send(svr,
0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_server_flush(svr);
free(p);
}
}
}
}
@ -1390,7 +1329,7 @@ _bt_clicked(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
/* Close all app-bmp-view windows here and clear mem */
if (g->sel_app)
{
app_info_st *st = g->sel_app->app->data;
app_info_st *st = g->sel_app->app;
_close_app_views(st, EINA_TRUE);
st->refresh_ctr++;
}
@ -1406,18 +1345,16 @@ static void
_bt_load_file(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
{
gui_elements *g = data;
Variant_st *app = calloc(1, sizeof(Variant_st));
Variant_st *td = calloc(1, sizeof(Variant_st));
/* app_info_st *app = NULL; */
app_info_st *app = calloc(1, sizeof(*app));
tree_data_st *td = calloc(1, sizeof(*td));
if (event_info)
{
Eina_Bool s = clouseau_data_eet_info_read(event_info,
(app_info_st **) &app->data,
(tree_data_st **) &td->data);
(app_info_st **) &app, (tree_data_st **) &td);
if (s)
{ /* Add the app to list of apps, then set this as selected app */
((app_info_st *) app->data)->file = strdup(event_info);
app->file = strdup(event_info);
app_data_st *st = _add_app(g, app);
st->td = td; /* This is the same as we got TREE_DATA message */
_set_selected_app(st, g->dd_list, NULL);
@ -1437,8 +1374,8 @@ _dismiss_save_dialog(void *data,
static void
_bt_save_file(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
{
app_info_st *app = gui->sel_app->app->data;
tree_data_st *ftd = gui->sel_app->td->data;
app_info_st *app = gui->sel_app->app;
tree_data_st *ftd = gui->sel_app->td;
if (event_info)
{
/* FIXME: Handle failure. */
@ -1504,19 +1441,16 @@ _save_file_dialog(void *data,
ck_bx = elm_box_add(g->save_inwin);
Eina_List *l;
app_info_st *a = g->sel_app->app->data;
tree_data_st *td = g->sel_app->td->data;
bmp_info_st *bmp;
app_info_st *a = g->sel_app->app;
tree_data_st *td = g->sel_app->td;
Clouseau_Tree_Item *treeit;
char buf[256];
EINA_LIST_FOREACH(td->tree, l, treeit)
{ /* First search app->view list if already have the window bmp */
Variant_st *v = (Variant_st *)
bmp_info_st *bmp = (bmp_info_st *)
eina_list_search_unsorted(a->view, _bmp_object_ptr_cmp,
(void *) (uintptr_t) treeit->ptr);
bmp = (v) ? v->data : NULL;
ck = elm_check_add(ck_bx);
evas_object_size_hint_weight_set(ck, EVAS_HINT_EXPAND, 1.0);
evas_object_size_hint_align_set(ck, EVAS_HINT_FILL, 0.0);
@ -1586,19 +1520,14 @@ _remove_apps_with_no_tree_data(gui_elements *g)
Eina_List *l, *l_next;
app_data_st *st;
app_closed_st t;
Variant_st *v;
EINA_LIST_FOREACH_SAFE(apps, l, l_next, st)
{
if (!st->td)
{ /* We actually fake APP_CLOSED message, for app NO tree */
t.ptr = (unsigned long long) (uintptr_t)
(((app_info_st *) st->app->data)->ptr);
(((app_info_st *) st->app)->ptr);
/* v is freed by _remove_app */
v = clouseau_data_variant_alloc(CLOUSEAU_APP_CLOSED,
sizeof(t), &t);
_remove_app(g, v); /* v->data is (app_closed_st *) */
_remove_app(g, &t);
}
}
}
@ -1645,8 +1574,7 @@ _show_gui(gui_elements *g, Eina_Bool work_offline)
elm_object_disabled_set(g->bt_save, (g->sel_app == NULL));
evas_object_show(g->bt_save);
svr = _connect_to_daemon(g);
if(!svr)
if (!_connect_to_daemon(g))
{
printf("Failed to connect to server.\n");
elm_exit(); /* exit the program's main loop,runs in elm_run() */
@ -1682,54 +1610,54 @@ _ofl_bt_clicked(void *data,
}
static void
_control_buttons_create(gui_elements *gui, Evas_Object *win)
_control_buttons_create(gui_elements *g, Evas_Object *win)
{
Evas_Object *show_hidden_check, *show_clippers_check, *highlight_check;
gui->hbx = elm_box_add(gui->bx);
evas_object_size_hint_align_set(gui->hbx, 0.0, 0.5);
elm_box_horizontal_set(gui->hbx, EINA_TRUE);
elm_box_pack_end(gui->bx, gui->hbx);
elm_box_padding_set(gui->hbx, 10, 0);
evas_object_show(gui->hbx);
g->hbx = elm_box_add(g->bx);
evas_object_size_hint_align_set(g->hbx, 0.0, 0.5);
elm_box_horizontal_set(g->hbx, EINA_TRUE);
elm_box_pack_end(g->bx, g->hbx);
elm_box_padding_set(g->hbx, 10, 0);
evas_object_show(g->hbx);
gui->bt_load = elm_button_add(gui->hbx);
evas_object_size_hint_align_set(gui->bt_load, 0.0, 0.3);
elm_box_pack_end(gui->hbx, gui->bt_load);
evas_object_show(gui->bt_load);
g->bt_load = elm_button_add(g->hbx);
evas_object_size_hint_align_set(g->bt_load, 0.0, 0.3);
elm_box_pack_end(g->hbx, g->bt_load);
evas_object_show(g->bt_load);
gui->dd_list = elm_hoversel_add(gui->hbx);
elm_hoversel_hover_parent_set(gui->dd_list, win);
elm_object_text_set(gui->dd_list, "SELECT APP");
g->dd_list = elm_hoversel_add(g->hbx);
elm_hoversel_hover_parent_set(g->dd_list, win);
elm_object_text_set(g->dd_list, "SELECT APP");
evas_object_size_hint_align_set(gui->dd_list, 0.0, 0.3);
elm_box_pack_end(gui->hbx, gui->dd_list);
evas_object_show(gui->dd_list);
evas_object_size_hint_align_set(g->dd_list, 0.0, 0.3);
elm_box_pack_end(g->hbx, g->dd_list);
evas_object_show(g->dd_list);
show_hidden_check = elm_check_add(gui->hbx);
show_hidden_check = elm_check_add(g->hbx);
elm_object_text_set(show_hidden_check, "Show Hidden");
elm_check_state_set(show_hidden_check, list_show_hidden);
elm_box_pack_end(gui->hbx, show_hidden_check);
elm_box_pack_end(g->hbx, show_hidden_check);
evas_object_show(show_hidden_check);
show_clippers_check = elm_check_add(gui->hbx);
show_clippers_check = elm_check_add(g->hbx);
elm_object_text_set(show_clippers_check, "Show Clippers");
elm_check_state_set(show_clippers_check, list_show_clippers);
elm_box_pack_end(gui->hbx, show_clippers_check);
elm_box_pack_end(g->hbx, show_clippers_check);
evas_object_show(show_clippers_check);
highlight_check = elm_check_add(gui->hbx);
highlight_check = elm_check_add(g->hbx);
elm_object_text_set(highlight_check , "Highlight");
elm_check_state_set(highlight_check , do_highlight);
elm_box_pack_end(gui->hbx, highlight_check);
elm_box_pack_end(g->hbx, highlight_check);
evas_object_show(highlight_check);
evas_object_smart_callback_add(show_hidden_check, "changed",
_show_hidden_check_changed, gui);
_show_hidden_check_changed, g);
evas_object_smart_callback_add(show_clippers_check, "changed",
_show_clippers_check_changed, gui);
_show_clippers_check_changed, g);
evas_object_smart_callback_add(highlight_check, "changed",
_highlight_check_check_changed, gui);
_highlight_check_check_changed, g);
}
static void
@ -1842,7 +1770,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
eina_init();
ecore_init();
ecore_ipc_init();
ecore_con_init();
clouseau_data_init();
/* START - Popup to get IP, PORT from user */

411
src/bin/clouseaud.c
View File

@ -3,7 +3,7 @@
#endif
#include <fcntl.h>
#include <Ecore_Ipc.h>
#include <Ecore_Con_Eet.h>
#include "clouseau_private.h"
@ -13,7 +13,7 @@
static Eina_List *gui = NULL; /* List of app_info_st for gui clients */
static Eina_List *app = NULL; /* List of app_info_st for app clients */
Ecore_Ipc_Server *ipc_svr = NULL;
static Ecore_Con_Eet *eet_svr = NULL;
/* For Debug */
char msg_buf[MAX_LINE+1];
@ -39,9 +39,11 @@ static void
_daemon_cleanup(void)
{ /* Free strings */
app_info_st *p;
time_t currentTime;
sprintf(msg_buf,"Clients connected to this server when exiting: %d\n",
eina_list_count(ecore_ipc_server_clients_get(ipc_svr)));
time (&currentTime);
sprintf(msg_buf,"\n\n%sClients connected to this server when exiting: %d\n"
, ctime(&currentTime), eina_list_count(app) + eina_list_count(gui));
log_message(LOG_FILE, "a", msg_buf);
EINA_LIST_FREE(gui, p)
@ -49,6 +51,9 @@ _daemon_cleanup(void)
if(p->file)
free(p->file);
if (p->ptr)
free((void *) (uint32_t) p->ptr);
free(p->name);
free(p);
}
@ -58,15 +63,18 @@ _daemon_cleanup(void)
if(p->file)
free(p->file);
if (p->ptr)
free((void *) (uint32_t) p->ptr);
free(p->name);
free(p);
}
gui = app = NULL;
ipc_svr = NULL;
eet_svr = NULL;
clouseau_data_shutdown();
ecore_ipc_shutdown();
ecore_con_shutdown();
ecore_shutdown();
eina_shutdown();
}
@ -115,15 +123,19 @@ _client_ptr_cmp(const void *d1, const void *d2)
}
static Eina_List *
_add_client(Eina_List *clients, connect_st *t, void *client)
_add_client(Eina_List *clients, connect_st *t, void *client, const char *type)
{
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, client);
log_message(LOG_FILE, "a", msg_buf);
if(!eina_list_search_unsorted(clients, _client_ptr_cmp, client))
{
app_info_st *st = calloc(1, sizeof(app_info_st));
st->name = strdup(t->name);
st->pid = t->pid;
st->ptr = (unsigned long long) (uintptr_t) client;
sprintf(msg_buf, "\tAdded %s client <%p>", type, client);
log_message(LOG_FILE, "a", msg_buf);
return eina_list_append(clients, st);
}
@ -131,13 +143,18 @@ _add_client(Eina_List *clients, connect_st *t, void *client)
}
static Eina_List *
_remove_client(Eina_List *clients, void *client)
_remove_client(Eina_List *clients, void *client, const char *type)
{
app_info_st *p = eina_list_search_unsorted(clients, _client_ptr_cmp, client);
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, client);
log_message(LOG_FILE, "a", msg_buf);
if (p)
{
free(p->name);
free(p);
sprintf(msg_buf, "\tRemoved %s client <%p>", type, client);
log_message(LOG_FILE, "a", msg_buf);
return eina_list_remove(clients, p);
}
@ -145,139 +162,111 @@ _remove_client(Eina_List *clients, void *client)
}
Eina_Bool
_add(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Client_Add *ev)
_add(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED Ecore_Con_Client *conn)
{
ecore_ipc_client_data_size_max_set(ev->client, -1);
sprintf(msg_buf, "<%s> msg from <%p>", __func__, ev->client);
/* TODO: ecore_ipc_client_data_size_max_set(ev->client, -1); */
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
return ECORE_CALLBACK_RENEW;
}
Eina_Bool
_del(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Client_Del *ev)
_del(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED Ecore_Con_Client *conn)
{
if (!ev->client)
return ECORE_CALLBACK_RENEW;
sprintf(msg_buf, "<%s> msg from <%p>", __func__, ev->client);
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
/* Now we need to find if its an APP or GUI client */
app_info_st *i = eina_list_search_unsorted(gui, _client_ptr_cmp, ev->client);
app_info_st *i = eina_list_search_unsorted(gui, _client_ptr_cmp, reply);
if (i) /* Only need to remove GUI client from list */
gui = _remove_client(gui, ev->client);
gui = _remove_client(gui, reply, "GUI");
i = eina_list_search_unsorted(app, _client_ptr_cmp, ev->client);
i = eina_list_search_unsorted(app, _client_ptr_cmp, reply);
if (i)
{ /* Notify all GUI clients to remove this APP */
app_closed_st t = { (unsigned long long) (uintptr_t) ev->client };
app_closed_st t = { (unsigned long long) (uintptr_t) reply };
Eina_List *l;
int size;
void *p = clouseau_data_packet_compose(CLOUSEAU_APP_CLOSED,
&t, sizeof(t), &size, NULL, 0);
if (p)
{
EINA_LIST_FOREACH(gui, l, i)
{
ecore_ipc_client_send((void *) (uintptr_t) i->ptr,
0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_client_flush((void *) (uintptr_t) i->ptr);
sprintf(msg_buf, "\t<%p> Sending APP_CLOSED to <%p>",
reply, (void *) (uint32_t) i->ptr);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uintptr_t) i->ptr,
CLOUSEAU_APP_CLOSED_STR, &t);
}
free(p);
app = _remove_client(app, reply, "APP");
}
app = _remove_client(app, ev->client);
}
ecore_ipc_client_del(ev->client);
if (!eina_list_count(ecore_ipc_server_clients_get(ipc_svr)))
if (!(gui || app))
{ /* Trigger cleanup and exit when all clients disconneced */
/* ecore_con_eet_server_free(eet_svr); why this causes Segfault? */
ecore_con_server_del(data);
ecore_main_loop_quit();
}
return ECORE_CALLBACK_RENEW;
}
Eina_Bool
_data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Client_Data *ev)
{
void *p;
int size = 0;
sprintf(msg_buf, "<%s> msg from <%p>", __func__, ev->client);
void
_gui_client_connect_cb(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* Register GUI, then notify about all APP */
app_info_st *st;
Eina_List *l;
connect_st *t = value;
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
Variant_st *v = clouseau_data_packet_info_get(ev->data, ev->size);
/* This is where daemon impl communication protocol.
* In order to simplify, all messages also contains recipient ptr
* as saved by daemon.
* Thus we only need to peek this info then FWD, reply to this recipient */
if (!v)
{
log_message(LOG_FILE, "a", "Failed to decode data.");
return ECORE_CALLBACK_RENEW;
}
gui = _add_client(gui, t, reply, "GUI");
switch(clouseau_data_packet_mapping_type_get(v->type))
{
case CLOUSEAU_APP_CLIENT_CONNECT:
{ /* Register APP then notify GUI about it */
app_info_st *st;
Eina_List *l;
connect_st *t = v->data;
app_info_st m = { t->pid, (char *) t->name, NULL,
(unsigned long long) (uintptr_t) ev->client, NULL, 0 };
app = _add_client(app, t, ev->client);
p = clouseau_data_packet_compose(CLOUSEAU_APP_ADD,
&m, sizeof(m), &size, NULL, 0);
if (p)
{
EINA_LIST_FOREACH(gui, l, st)
{ /* Notify all GUI clients to add APP */
ecore_ipc_client_send(
(void *) (uintptr_t) st->ptr,
0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_client_flush(
(void *) (uintptr_t) st->ptr);
}
free(p);
}
}
break;
case CLOUSEAU_GUI_CLIENT_CONNECT:
{ /* Register GUI, then notify about all APP */
app_info_st *st;
Eina_List *l;
connect_st *t = v->data;
gui = _add_client(gui, t, ev->client);
/* Add all registered apps to newly open GUI */
EINA_LIST_FOREACH(app, l, st)
{ /* Add all registered apps to newly open GUI */
p = clouseau_data_packet_compose(CLOUSEAU_APP_ADD,
st, sizeof(*st), &size, NULL, 0);
if (p)
{
ecore_ipc_client_send(ev->client,
0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_client_flush(ev->client);
free(p);
}
sprintf(msg_buf, "\t<%p> Sending APP_ADD to <%p>",
(void *) (uint32_t) st->ptr, reply);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send(reply, CLOUSEAU_APP_ADD_STR, st);
}
}
}
break;
void
_app_client_connect_cb(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* Register APP then notify GUI about it */
app_info_st *st;
Eina_List *l;
connect_st *t = value;
app_info_st m = { t->pid, (char *) t->name, NULL,
(unsigned long long) (uintptr_t) reply, NULL, 0 };
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
app = _add_client(app, t, reply, "APP");
/* Notify all GUI clients to add APP */
EINA_LIST_FOREACH(gui, l, st)
{
sprintf(msg_buf, "\t<%p> Sending APP_ADD to <%p>",
reply, (void *) (uint32_t) st->ptr);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uint32_t) st->ptr,
CLOUSEAU_APP_ADD_STR, &m);
}
}
void
_data_req_cb(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* msg coming from GUI, FWD this to APP specified in REQ */
data_req_st *req = value;
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
case CLOUSEAU_DATA_REQ:
{ /* msg coming from GUI, FWD this to app specified in req */
data_req_st *req = v->data;
if (req->app)
{ /* Requesting specific app data */
if(eina_list_search_unsorted(app,
@ -285,21 +274,14 @@ _data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Client_Data
(void *) (uintptr_t) req->app))
{ /* Do the req only of APP connected to daemon */
data_req_st t = {
(unsigned long long) (uintptr_t) ev->client,
(unsigned long long) (uintptr_t) reply,
(unsigned long long) (uintptr_t) req->app };
p = clouseau_data_packet_compose(CLOUSEAU_DATA_REQ,
&t, sizeof(t), &size, NULL, 0);
if (p)
{
ecore_ipc_client_send(
(void *) (uintptr_t) req->app,
0,0,0,0, EINA_FALSE, p, size);
ecore_ipc_client_flush(
(void *) (uintptr_t) req->app);
free(p);
}
sprintf(msg_buf, "\t<%p> Sending DATA_REQ to <%p>",
reply, (void *) (uint32_t) req->app);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uint32_t) req->app,
CLOUSEAU_DATA_REQ_STR, &t);
}
}
else
@ -307,43 +289,39 @@ _data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Client_Data
Eina_List *l;
app_info_st *st;
data_req_st t = {
(unsigned long long) (uintptr_t) ev->client,
(unsigned long long) (uintptr_t) reply,
(unsigned long long) (uintptr_t) NULL };
EINA_LIST_FOREACH(app, l, st)
{
t.app = (unsigned long long) (uintptr_t) st->ptr;
p = clouseau_data_packet_compose(CLOUSEAU_DATA_REQ,
&t, sizeof(t), &size, NULL, 0);
sprintf(msg_buf, "\t<%p> Sending DATA_REQ to <%p>",
reply, (void *) (uint32_t) st->ptr);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uint32_t) st->ptr, CLOUSEAU_DATA_REQ_STR, &t);
}
}
}
if (p)
{
ecore_ipc_client_send(
(void *) (uintptr_t) st->ptr,
0,0,0,0, EINA_FALSE, p, size);
ecore_ipc_client_flush(
(void *) (uintptr_t) st->ptr);
free(p);
}
}
}
}
break;
void
_tree_data_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* Tree Data comes from APP, GUI client specified in msg */
tree_data_st *td = value;
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
case CLOUSEAU_TREE_DATA:
{ /* Tree Data comes from APP, GUI client specified in msg */
tree_data_st *td = v->data;
if (td->gui)
{ /* Sending tree data to specific GUI client */
if(eina_list_search_unsorted(gui,
_client_ptr_cmp,
(void *) (uintptr_t) td->gui))
{ /* Do the req only of GUI connected to daemon */
ecore_ipc_client_send(
(void *) (uintptr_t) td->gui, 0,0,0,0,
EINA_FALSE, ev->data, ev->size);
ecore_ipc_client_flush(
(void *) (uintptr_t) td->gui);
sprintf(msg_buf, "\t<%p> Sending TREE_DATA to <%p>",
reply, (void *) (uint32_t) td->gui);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uint32_t) td->gui,
CLOUSEAU_TREE_DATA_STR, value);
}
}
else
@ -352,72 +330,81 @@ _data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Client_Data
app_info_st *info;
EINA_LIST_FOREACH(gui, l, info)
{
ecore_ipc_client_send(
(void *) (uintptr_t) info->ptr, 0,0,0,0,
EINA_FALSE, ev->data, ev->size);
ecore_ipc_client_flush(
(void *) (uintptr_t) info->ptr);
sprintf(msg_buf, "\t<%p> Sending TREE_DATA to <%p>",
reply, (void *) (uint32_t) info->ptr);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uint32_t) info->ptr,
CLOUSEAU_TREE_DATA_STR, value);
}
}
clouseau_data_tree_free(td->tree);
}
break;
}
void
_highlight_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* FWD this message to APP */
highlight_st *ht = value;
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
case CLOUSEAU_HIGHLIGHT:
{ /* FWD this message to app */
highlight_st *ht = v->data;
if(eina_list_search_unsorted(app,
_client_ptr_cmp, (void *) (uintptr_t) ht->app))
{ /* Do the req only of APP connected to daemon */
ecore_ipc_client_send((void *)
(uintptr_t) ht->app, 0,0,0,0,
EINA_FALSE, ev->data, ev->size);
ecore_ipc_client_flush((void *) (uintptr_t) ht->app);
{ /* Do the REQ only of APP connected to daemon */
sprintf(msg_buf, "\t<%p> Sending HIGHLIGHT to <%p>",
reply, (void *) (uint32_t) ht->app);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uint32_t) ht->app,
CLOUSEAU_HIGHLIGHT_STR, value);
}
}
break;
}
void
_bmp_req_cb(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* BMP data request coming from GUI to APP client */
bmp_req_st *req = value;
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
case CLOUSEAU_BMP_REQ:
{
bmp_req_st *req = v->data;
if(eina_list_search_unsorted(app,
_client_ptr_cmp, (void *) (uintptr_t) req->app))
{ /* Do the req only of APP connected to daemon */
{ /* Do the req only if APP connected to daemon */
bmp_req_st t = {
(unsigned long long) (uintptr_t) ev->client,
(unsigned long long) (uintptr_t) reply,
req->app, req->object, req->ctr };
p = clouseau_data_packet_compose(CLOUSEAU_BMP_REQ,
&t, sizeof(t), &size, NULL, 0);
sprintf(msg_buf, "\t<%p> Sending BMP_REQ to <%p>",
reply, (void *) (uint32_t) req->app);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_send((void *) (uint32_t) req->app,
CLOUSEAU_BMP_REQ_STR, &t);
}
}
if (p)
{ /* FWD req to app with client data */
ecore_ipc_client_send(
(void *) (uintptr_t) req->app,
0,0,0,0, EINA_FALSE, p, size);
ecore_ipc_client_flush(
(void *) (uintptr_t) req->app);
free(p);
}
}
}
break;
void
_bmp_data_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, EINA_UNUSED const char *section,
void *value, EINA_UNUSED size_t length)
{ /* BMP Data comes from APP, GUI client specified in msg */
bmp_info_st *st = clouseau_data_packet_info_get(protocol_name,
value, length);
sprintf(msg_buf, "\n<%s> msg from <%p>", __func__, reply);
log_message(LOG_FILE, "a", msg_buf);
case CLOUSEAU_BMP_DATA:
{ /* Bmp Data comes from APP, GUI client specified in msg */
bmp_info_st *st = v->data;
if (st->gui)
{ /* Sending BMP data to specific GUI client */
if(eina_list_search_unsorted(gui,
_client_ptr_cmp,
(void *) (uintptr_t) st->gui))
{ /* Do the req only of GUI connected to daemon */
ecore_ipc_client_send(
(void *) (uintptr_t) st->gui, 0,0,0,0,
EINA_FALSE, ev->data, ev->size);
ecore_ipc_client_flush(
(void *) (uintptr_t) st->gui);
sprintf(msg_buf, "\t<%p> Sending BMP_DATA to <%p>",
reply, (void *) (uint32_t) st->gui);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_raw_send((void *) (uint32_t) st->gui,
CLOUSEAU_BMP_DATA_STR, "BMP", value, length);
}
}
else
@ -426,27 +413,18 @@ _data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Client_Data
app_info_st *info;
EINA_LIST_FOREACH(gui, l, info)
{
ecore_ipc_client_send(
(void *) (uintptr_t) info->ptr, 0,0,0,0,
EINA_FALSE, ev->data, ev->size);
ecore_ipc_client_flush(
(void *) (uintptr_t) info->ptr);
sprintf(msg_buf, "\t<%p> Sending BMP_DATA to <%p>",
reply, (void *) (uint32_t) info->ptr);
log_message(LOG_FILE, "a", msg_buf);
ecore_con_eet_raw_send((void *) (uint32_t) info->ptr,
CLOUSEAU_BMP_DATA_STR, "BMP", value, length);
}
}
if (st->bmp)
free(st->bmp);
}
break;
default:
break;
}
clouseau_data_variant_free(v);
log_message(LOG_FILE, "a", "_data() finished");
return ECORE_CALLBACK_RENEW;
free(st);
}
/* END - Ecore communication callbacks */
@ -455,18 +433,37 @@ int main(void)
daemonize();
eina_init();
ecore_init();
ecore_ipc_init();
ecore_con_init();
clouseau_data_init();
Ecore_Con_Server *server = NULL;
if (!(ipc_svr = ecore_ipc_server_add(ECORE_IPC_REMOTE_SYSTEM,
if (!(server = ecore_con_server_add(ECORE_CON_REMOTE_TCP,
LISTEN_IP, PORT, NULL)))
exit(1);
ecore_ipc_server_data_size_max_set(ipc_svr, -1);
eet_svr = ecore_con_eet_server_new(server);
if (!eet_svr)
exit(2);
ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL);
ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL);
ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_data, NULL);
clouseau_register_descs(eet_svr);
/* Register callbacks for ecore_con_eet */
ecore_con_eet_client_connect_callback_add(eet_svr, _add, NULL);
ecore_con_eet_client_disconnect_callback_add(eet_svr, _del, server);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_GUI_CLIENT_CONNECT_STR,
_gui_client_connect_cb, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_APP_CLIENT_CONNECT_STR,
_app_client_connect_cb, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_DATA_REQ_STR,
_data_req_cb, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_TREE_DATA_STR,
_tree_data_cb, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_HIGHLIGHT_STR,
_highlight_cb, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_BMP_REQ_STR,
_bmp_req_cb, NULL);
ecore_con_eet_raw_data_callback_add(eet_svr, CLOUSEAU_BMP_DATA_STR,
_bmp_data_cb, NULL);
ecore_main_loop_begin();
_daemon_cleanup();

147
src/lib/clouseau_client.c
View File

@ -2,7 +2,7 @@
#include <dlfcn.h>
#include <execinfo.h>
#include <Ecore_Ipc.h>
#include <Ecore_Con_Eet.h>
#include <Edje.h>
#include <Evas.h>
#include <Elementary.h>
@ -139,58 +139,41 @@ _load_list(void)
return tree; /* User has to call clouseau_tree_free() */
}
static Eina_Bool
_add(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Server_Add *ev)
Eina_Bool
_add(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED Ecore_Con_Server *conn)
{
void *p;
int size = 0;
ecore_ipc_server_data_size_max_set(ev->server, -1);
/* ecore_con_server_data_size_max_set(conn, -1); */
connect_st t = { getpid(), _my_app_name };
p = clouseau_data_packet_compose(CLOUSEAU_APP_CLIENT_CONNECT,
&t, sizeof(t), &size, NULL, 0);
if (p)
{
ecore_ipc_server_send(ev->server, 0,0,0,0,EINA_FALSE, p, size);
ecore_ipc_server_flush(ev->server);
free(p);
}
ecore_con_eet_send(reply, CLOUSEAU_APP_CLIENT_CONNECT_STR, &t);
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_del(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Server_Del *ev)
Eina_Bool
_del(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
Ecore_Con_Server *conn)
{
if (!ev->server)
if (!conn)
{
printf("Failed to establish connection to the server.\nExiting.\n");
ecore_main_loop_quit();
return ECORE_CALLBACK_RENEW;
}
printf("Lost server with ip %s!\n", ecore_ipc_server_ip_get(ev->server));
printf("Lost server with ip <%s>\n", ecore_con_server_ip_get(conn));
ecore_ipc_server_del(ev->server);
ecore_con_server_del(conn);
ecore_main_loop_quit();
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Server_Data *ev)
{
Variant_st *v;
v = clouseau_data_packet_info_get(ev->data, ev->size);
switch (clouseau_data_packet_mapping_type_get(v->type))
{
case CLOUSEAU_DATA_REQ:
{ /* data req includes ptr to GUI, to tell which client asking */
int size = 0;
data_req_st *req = v->data;
void
_data_req_cb(EINA_UNUSED void *data, Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* data req includes ptr to GUI, to tell which client asking */
data_req_st *req = value;
tree_data_st t;
t.gui = req->gui; /* GUI client requesting data from daemon */
t.app = req->app; /* APP client sending data to daemon */
@ -198,35 +181,27 @@ _data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Server_Data
if (t.tree)
{ /* Reply with tree data to data request */
void *p = clouseau_data_packet_compose(CLOUSEAU_TREE_DATA,
&t, sizeof(t), &size, NULL, 0);
if (p)
{
ecore_ipc_server_send(ev->server, 0,0,0,0,
EINA_FALSE, p, size);
ecore_ipc_server_flush(ev->server);
free(p);
}
ecore_con_eet_send(reply, CLOUSEAU_TREE_DATA_STR, &t);
clouseau_data_tree_free(t.tree);
}
}
break;
}
case CLOUSEAU_HIGHLIGHT:
{ /* Highlight msg contains PTR of object to highlight */
highlight_st *ht = v->data;
void
_highlight_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* Highlight msg contains PTR of object to highlight */
highlight_st *ht = value;
Evas_Object *obj = (Evas_Object *) (uintptr_t) ht->object;
clouseau_data_object_highlight(obj, NULL, NULL);
}
break;
}
case CLOUSEAU_BMP_REQ:
{ /* Bitmap req msg contains PTR of Ecore Evas */
bmp_req_st *req = v->data;
void
_bmp_req_cb(EINA_UNUSED void *data, EINA_UNUSED Ecore_Con_Reply *reply,
EINA_UNUSED const char *protocol_name, void *value)
{ /* Bitmap req msg contains PTR of Ecore Evas */
bmp_req_st *req = value;
Evas_Coord w, h;
int size = 0;
unsigned int size = 0;
void *bmp = _canvas_bmp_get((Ecore_Evas *) (uintptr_t)
req->object, &w, &h);
@ -235,61 +210,59 @@ _data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Ipc_Event_Server_Data
NULL,NULL, NULL, 1.0,
NULL, NULL, NULL, NULL, NULL, NULL };
void *p = clouseau_data_packet_compose(CLOUSEAU_BMP_DATA,
&t, sizeof(t), &size, bmp, (w * h * sizeof(int)));
void *p = clouseau_data_packet_compose(CLOUSEAU_BMP_DATA_STR,
&t, &size, bmp, (w * h * sizeof(int)));
if (p)
{
ecore_ipc_server_send(ev->server, 0,0,0,0,
EINA_FALSE, p, size);
ecore_ipc_server_flush(ev->server);
ecore_con_eet_raw_send(reply, CLOUSEAU_BMP_DATA_STR, "BMP", p, size);
free(p);
}
if (bmp)
free(bmp);
}
break;
default:
break;
}
clouseau_data_variant_free(v);
return ECORE_CALLBACK_RENEW;
}
static int
static Eina_Bool
_connect_to_daemon(void)
{
Ecore_Ipc_Server *svr;
Ecore_Con_Server *server;
const char *address = LOCALHOST;
Ecore_Con_Eet *eet_svr = NULL;
eina_init();
ecore_init();
ecore_ipc_init();
ecore_con_init();
svr = ecore_ipc_server_connect(ECORE_IPC_REMOTE_SYSTEM,
server = ecore_con_server_connect(ECORE_CON_REMOTE_TCP,
LOCALHOST, PORT, NULL);
if (!svr)
if (!server)
{
printf("could not connect to the server: %s, port %d.\n",
address, PORT);
return EINA_FALSE;
}
ecore_ipc_server_data_size_max_set(svr, -1);
eet_svr = ecore_con_eet_client_new(server);
if (!eet_svr)
{
printf("could not create con_eet client.\n");
return EINA_FALSE;
}
/* set event handler for server connect */
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_ADD,
(Ecore_Event_Handler_Cb)_add, NULL);
/* set event handler for server disconnect */
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DEL,
(Ecore_Event_Handler_Cb)_del, NULL);
/* set event handler for receiving server data */
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DATA,
(Ecore_Event_Handler_Cb)_data, NULL);
clouseau_register_descs(eet_svr);
/* Register callbacks for ecore_con_eet */
ecore_con_eet_server_connect_callback_add(eet_svr, _add, NULL);
ecore_con_eet_server_disconnect_callback_add(eet_svr, _del, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_DATA_REQ_STR,
_data_req_cb, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_HIGHLIGHT_STR,
_highlight_cb, NULL);
ecore_con_eet_data_callback_add(eet_svr, CLOUSEAU_BMP_REQ_STR,
_bmp_req_cb, NULL);
return EINA_TRUE;
}
@ -324,14 +297,14 @@ ecore_main_loop_begin(void)
_my_app_name = "clouseau";
}
clouseau_data_init();
if(!_connect_to_daemon())
{
printf("Failed to connect to server.\n");
return;
}
clouseau_data_init();
_ecore_main_loop_begin();
clouseau_data_shutdown();

329
src/lib/clouseau_data.c
View File

@ -19,7 +19,6 @@ static Eet_Data_Descriptor *clouseau_tree_edd = NULL;
static Eet_Data_Descriptor *clouseau_app_closed_edd = NULL;
static Eet_Data_Descriptor *clouseau_highlight_edd = NULL;
static Eet_Data_Descriptor *clouseau_bmp_req_edd = NULL;
static Eet_Data_Descriptor *clouseau_variant_edd = NULL;
static Eet_Data_Descriptor *clouseau_protocol_edd = NULL;
static Eet_Data_Descriptor *clouseau_map_point_props_edd = NULL;
@ -45,97 +44,6 @@ clouseau_data_tree_free(Eina_List *tree)
_clouseau_tree_item_free(treeit);
}
static const struct {
Clouseau_Message_Type t;
const char *name;
} eet_mapping[] = {
{ CLOUSEAU_GUI_CLIENT_CONNECT, "GUI_CONNECT" },
{ CLOUSEAU_APP_CLIENT_CONNECT, "APP_CONNECT" },
{ CLOUSEAU_APP_ADD, "APP_ADD" },
{ CLOUSEAU_DATA_REQ, "DATA_REQ" },
{ CLOUSEAU_TREE_DATA, "TREE_DATA" },
{ CLOUSEAU_APP_CLOSED, "APP_CLOSED" },
{ CLOUSEAU_HIGHLIGHT, "HIGHLIGHT" },
{ CLOUSEAU_BMP_REQ, "BMP_REQ" },
{ CLOUSEAU_BMP_DATA, "BMP_DATA" },
{ CLOUSEAU_UNKNOWN, NULL }
};
EAPI Clouseau_Message_Type
clouseau_data_packet_mapping_type_get(const char *name)
{
int i;
if (!name)
return CLOUSEAU_UNKNOWN;
for (i = 0; eet_mapping[i].name != NULL; ++i)
if (strcmp(name, eet_mapping[i].name) == 0)
return eet_mapping[i].t;
return CLOUSEAU_UNKNOWN;
}
static const char *
_clouseau_packet_mapping_type_str_get(Clouseau_Message_Type t)
{
int i;
for (i = 0; eet_mapping[i].name != NULL; ++i)
if (t == eet_mapping[i].t)
return eet_mapping[i].name;
return NULL;
}
static const char *
_clouseau_variant_type_get(const void *data, Eina_Bool *unknow EINA_UNUSED)
{
const char * const *type = data;
int i;
for (i = 0; eet_mapping[i].name != NULL; ++i)
if (strcmp(*type, eet_mapping[i].name) == 0)
return eet_mapping[i].name;
return NULL;
}
static Eina_Bool
_clouseau_variant_type_set(const char *type,
void *data,
Eina_Bool unknow EINA_UNUSED)
{
const char **t = data;
*t = type;
return EINA_TRUE;
}
EAPI void
clouseau_data_variant_free(Variant_st *v)
{
if (v->data)
free(v->data);
free(v);
}
EAPI Variant_st *
clouseau_data_variant_alloc(Clouseau_Message_Type t, size_t size, void *info)
{
Variant_st *v;
if (t == CLOUSEAU_UNKNOWN) return NULL;
/* This will allocate variant and message struct */
v = malloc(sizeof(Variant_st));
v->data = malloc(size);
_clouseau_variant_type_set(_clouseau_packet_mapping_type_str_get(t),
&v->type, EINA_FALSE);
memcpy(v->data, info, size);
return v;
}
static void
_clouseau_connect_desc_make(void)
{
@ -571,8 +479,6 @@ _clouseau_object_desc_make(void)
static void
clouseau_data_descriptors_init(void)
{
Eet_Data_Descriptor_Class eddc;
_clouseau_bmp_req_desc_make();
_clouseau_bmp_info_desc_make();
_clouseau_shot_list_desc_make();
@ -584,36 +490,6 @@ clouseau_data_descriptors_init(void)
_clouseau_tree_data_desc_make();
_clouseau_app_closed_desc_make();
_clouseau_highlight_desc_make();
/* for variant */
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Variant_st);
clouseau_protocol_edd = eet_data_descriptor_file_new(&eddc);
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
eddc.func.type_get = _clouseau_variant_type_get;
eddc.func.type_set = _clouseau_variant_type_set;
clouseau_variant_edd = eet_data_descriptor_stream_new(&eddc);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"GUI_CONNECT", clouseau_connect_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"APP_CONNECT", clouseau_connect_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"APP_ADD" , clouseau_app_add_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"DATA_REQ", clouseau_data_req_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"TREE_DATA", clouseau_tree_data_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"APP_CLOSED", clouseau_app_closed_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"HIGHLIGHT", clouseau_highlight_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"BMP_REQ", clouseau_bmp_req_edd);
EET_DATA_DESCRIPTOR_ADD_MAPPING(clouseau_variant_edd,
"BMP_DATA", clouseau_bmp_info_edd);
EET_DATA_DESCRIPTOR_ADD_VARIANT(clouseau_protocol_edd, Variant_st,
"data", data, type, clouseau_variant_edd);
}
static void
@ -626,7 +502,6 @@ clouseau_data_descriptors_shutdown(void)
eet_data_descriptor_free(clouseau_app_closed_edd);
eet_data_descriptor_free(clouseau_highlight_edd);
eet_data_descriptor_free(clouseau_object_edd);
eet_data_descriptor_free(clouseau_variant_edd);
eet_data_descriptor_free(clouseau_bmp_req_edd);
eet_data_descriptor_free(clouseau_bmp_info_edd);
eet_data_descriptor_free(clouseau_shot_list_edd);
@ -689,124 +564,110 @@ _net_to_host_blob_get(void *blob, int blob_size)
}
EAPI void *
clouseau_data_packet_compose(Clouseau_Message_Type t, void *data,
int data_size, int *size,
void *blob, int blob_size)
{
/* Returns packet BLOB and size in size param, NULL on failure */
/* Packet is composed of packet type BYTE + packet data. */
void *p = NULL;
void *pb = NULL;
unsigned char p_type = VARIANT_PACKET;
Variant_st *v;
clouseau_data_packet_compose(const char *p_type, void *data,
unsigned int *size, void *blob, int blob_size)
{ /* Returns packet BLOB and size in size param, NULL on failure */
/* User has to free returned buffer */
/* Packet is composed of Message Type + packet data. */
void *net_blob = NULL;
switch (t)
{
case CLOUSEAU_BMP_DATA:
if (!strcmp(p_type, CLOUSEAU_BMP_DATA_STR))
{ /* Builed Bitmap data as follows:
First we have encoding size of bmp_info_st
(Done Network Byte Order)
First uint32_t is encoding size of bmp_info_st
The next to come will be the encoded bmp_info_st itself
Then we have blob_size param (specifiying bmp-blob-size)
folloed by the Bitmap raw data. */
/* First, we like to encode bmp_info_st from data */
int t_size; /* total size */
int e_size;
uint32_t enc_size;
void *net_blob;
uint32_t e_size32;
uint32_t tmp;
void *p;
char *b;
char *ptr;
v = clouseau_data_variant_alloc(t, data_size, data);
p = eet_data_descriptor_encode(clouseau_protocol_edd, v, &e_size);
clouseau_data_variant_free(v);
/* First, we like to encode bmp_info_st from data */
p = eet_data_descriptor_encode(clouseau_bmp_info_edd, data, &e_size);
e_size32 = (uint32_t) e_size;
/* Allocate buffer to hold whole packet data */
t_size = sizeof(e_size32) + /* encoding size of bmp_info_st */
+ e_size /* Encoded bmp_info_st */
+ sizeof(e_size32) /* bmp-blob-size */
+ blob_size; /* The BMP blob data */
ptr = b = malloc(t_size);
/* START - Build BMP_RAW_DATA packet data */
/* Size of encoded bmp_info_st comes next in uint32 format */
memcpy(ptr, &e_size32, sizeof(e_size32));
ptr += sizeof(e_size32);
/* Encoded bmp_info_st comes next */
memcpy(ptr, p, e_size);
ptr += e_size;
/* Size of BMP blob comes next */
tmp = (uint32_t) blob_size;
memcpy(ptr, &tmp, sizeof(uint32_t));
ptr += sizeof(uint32_t);
if (blob && blob_size)
{ /* BMP blob info comes right after BMP blob_size */
memcpy(ptr, blob, blob_size);
}
/* Save encoded size in network format */
enc_size = htonl((uint32_t) e_size);
net_blob = _host_to_net_blob_get(blob, &blob_size);
net_blob = _host_to_net_blob_get(b, &t_size);
*size = t_size; /* Update packet size */
/* Update size to the buffer size we about to return */
*size = (e_size + blob_size + sizeof(enc_size));
b = malloc(*size);
/* Copy encoded-size first, followd by encoded data */
memcpy(b, &enc_size, sizeof(enc_size));
memcpy(b + sizeof(enc_size), p, e_size);
/* All info now in net_blob, free allocated mem */
free(b);
free(p);
if (net_blob) /* Copy BMP info */
{
memcpy(b + sizeof(enc_size) + e_size, net_blob, blob_size);
free(net_blob);
/* END - Build BMP_RAW_DATA packet data */
}
p_type = BMP_RAW_DATA;
p = b;
}
break;
default:
{
/* All others are variant packets with EET encoding */
/* Variant is composed of message type + ptr to data */
v = clouseau_data_variant_alloc(t, data_size, data);
p = eet_data_descriptor_encode(clouseau_protocol_edd, v, size);
clouseau_data_variant_free(v);
}
}
pb = malloc((*size) + 1);
*((unsigned char *) pb) = p_type;
memcpy(((char *) pb) + 1, p, *size);
*size = (*size) + 1; /* Add space for packet type */
free(p);
return pb; /* User has to free(pb) */
return net_blob;
}
EAPI Variant_st *
clouseau_data_packet_info_get(void *data, int size)
EAPI void *
clouseau_data_packet_info_get(const char *p_type, void *data, size_t size)
{
/* user has to use variant_free() to free return struct */
char *ch = data;
Variant_st *v;
bmp_info_st *st = NULL;
void *host_blob = _net_to_host_blob_get(data, size);
char *ptr = host_blob;
if (size <= 0)
return NULL;
switch (*ch)
if (!strcmp(p_type, CLOUSEAU_BMP_DATA_STR))
{
case BMP_RAW_DATA:
{
void *bmp = NULL;
bmp_info_st *st;
char *b;
uint32_t enc_size;
int blob_size;
uint32_t *e_size32 = (uint32_t *) ptr;
int e_size = (int) (*e_size32); /* First Encoded bmp_info_st size */
ptr += sizeof(uint32_t);
b = (char *) (ch + 1);
enc_size = ntohl(*(uint32_t *) b);
/* blob_size is total size minus 1st byte and enc_size size */
blob_size = size - (enc_size + 1 + sizeof(enc_size));
if (blob_size)
{
/* Allocate BMP only if was included in packet */
bmp = _net_to_host_blob_get(b + sizeof(enc_size) + enc_size,
blob_size);
/* Get the encoded bmp_info_st */
st = eet_data_descriptor_decode(clouseau_bmp_info_edd
,ptr, e_size);
ptr += e_size;
st->bmp = NULL;
/* Next Get bmp-blob-size */
e_size32 = (uint32_t *) ptr;
e_size = (int) (*e_size32); /* Get bmp-blob size */
ptr += sizeof(uint32_t);
/* Now we need to get the bmp data */
if (e_size)
{ /* BMP data available, allocate and copy */
st->bmp = malloc(e_size); /* Freed by user */
memcpy(st->bmp, ptr, e_size);
}
} /* User has to free st, st->bmp */
/* User have to free both: variant_free(rt), free(t->bmp) */
v = eet_data_descriptor_decode(clouseau_protocol_edd,
b + sizeof(enc_size), enc_size);
st = v->data;
st->bmp = bmp;
return v;
}
break;
default:
return eet_data_descriptor_decode(clouseau_protocol_edd,
ch + 1, size - 1);
}
free(host_blob);
return st;
}
/* HIGHLIGHT code. */
@ -1022,7 +883,6 @@ clouseau_data_eet_info_read(const char *filename,
EINA_LIST_FREE(t->view, st)
{
Variant_st *v;
char buf[1024];
int alpha;
int compress;
@ -1036,8 +896,7 @@ clouseau_data_eet_info_read(const char *filename,
&alpha, &compress, &quality, &lossy);
/* Add the bitmaps to the actuall app data struct */
v = clouseau_data_variant_alloc(CLOUSEAU_BMP_DATA, sizeof(*st), st);
(*a)->view = eina_list_append((*a)->view, v);
(*a)->view = eina_list_append((*a)->view, st);
}
free(t);
@ -1061,6 +920,34 @@ clouseau_data_init(void)
return clouseau_init_count;
}
EAPI int
clouseau_register_descs(Ecore_Con_Eet *eet_svr)
{ /* Register descriptors for ecore_con_eet */
if (clouseau_init_count)
{ /* MUST be called after clouseau_data_init */
ecore_con_eet_register(eet_svr, CLOUSEAU_GUI_CLIENT_CONNECT_STR,
clouseau_connect_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_APP_CLIENT_CONNECT_STR,
clouseau_connect_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_APP_ADD_STR,
clouseau_app_add_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_DATA_REQ_STR,
clouseau_data_req_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_TREE_DATA_STR,
clouseau_tree_data_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_APP_CLOSED_STR,
clouseau_app_closed_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_HIGHLIGHT_STR,
clouseau_highlight_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_BMP_REQ_STR,
clouseau_bmp_req_edd);
ecore_con_eet_register(eet_svr, CLOUSEAU_BMP_DATA_STR,
clouseau_bmp_info_edd);
}
return clouseau_init_count;
}
EAPI int
clouseau_data_shutdown(void)
{

61
src/lib/clouseau_private.h
View File

@ -1,6 +1,7 @@
#ifndef EET_DATA_H
#define EET_DATA_H
#include "Clouseau.h"
#include <Ecore_Con_Eet.h>
/* Global constants */
#define BMP_FIELD "bmp"
@ -9,33 +10,21 @@
#define LOCALHOST "127.0.0.1"
#define LISTEN_IP "0.0.0.0" /* Avail all, no mask */
/* Define packet types, used by packet encode / decode */
#define VARIANT_PACKET 0
#define BMP_RAW_DATA 1
#define CLOUSEAU_GUI_CLIENT_CONNECT_STR "CLOUSEAU_GUI_CLIENT_CONNECT"
#define CLOUSEAU_APP_CLIENT_CONNECT_STR "CLOUSEAU_APP_CLIENT_CONNECT"
#define CLOUSEAU_APP_ADD_STR "CLOUSEAU_APP_ADD"
#define CLOUSEAU_DATA_REQ_STR "CLOUSEAU_DATA_REQ"
#define CLOUSEAU_TREE_DATA_STR "CLOUSEAU_TREE_DATA"
#define CLOUSEAU_APP_CLOSED_STR "CLOUSEAU_APP_CLOSED"
#define CLOUSEAU_HIGHLIGHT_STR "CLOUSEAU_HIGHLIGHT"
#define CLOUSEAU_BMP_REQ_STR "CLOUSEAU_BMP_REQ"
#define CLOUSEAU_BMP_DATA_STR "CLOUSEAU_BMP_DATA"
enum _Clouseau_Message_Type
{ /* Add any supported types of packets here */
CLOUSEAU_UNKNOWN = 0,
CLOUSEAU_GUI_CLIENT_CONNECT = 1, /* client PID, name */
CLOUSEAU_APP_CLIENT_CONNECT = 2, /* client PID, name */
CLOUSEAU_APP_ADD = 3, /* client PTR, name, PID fwd to GUI client */
CLOUSEAU_DATA_REQ = 4, /* GUI client PTR (NULL for all),APP client PTR (NULL for all) */
CLOUSEAU_TREE_DATA = 5, /* GUI client PTR (NULL for all),APP client PTR, Tree Data */
CLOUSEAU_APP_CLOSED = 6,/* APP client PTR from DAEMON to GUI */
CLOUSEAU_HIGHLIGHT = 7, /* APP client PTR, object PTR */
CLOUSEAU_BMP_REQ = 8, /* APP client PTR, object PTR */
CLOUSEAU_BMP_DATA = 9 /* bmp_info_st header + BMP raw data */
};
typedef enum _Clouseau_Message_Type Clouseau_Message_Type;
/* This is used for composing message and encoding/decoding with EET */
struct _Variant_st
{
const char *type;
void *data;
};
typedef struct _Variant_st Variant_st;
/* Private function */
#define CLOUSEAU_APP_ADD_ENTRY "clouseau/app"
#define CLOUSEAU_TREE_DATA_ENTRY "clouseau/app/tree"
#define CLOUSEAU_BMP_LIST_ENTRY "clouseau/app/shot_list"
#define CLOUSEAU_BMP_DATA_ENTRY "clouseau/app/screenshot"
struct _connect_st
{ /* This will be used for APP, GUI client connect */
@ -50,7 +39,7 @@ struct _app_info_st
char *name;
char *file; /* Valid only if was read from file in offline mode */
unsigned long long ptr; /* (void *) client ptr of app as saved by daemon */
Eina_List *view; /* Screen views view->data is (bmp_info_st *) ptr */
Eina_List *view; /* Screen views pointers of (bmp_info_st *) */
unsigned int refresh_ctr; /* Counter of how many times down refresh */
};
typedef struct _app_info_st app_info_st;
@ -137,33 +126,21 @@ struct _data_desc
Eet_Data_Descriptor *highlight;
Eet_Data_Descriptor *tree;
Eet_Data_Descriptor *obj_info;
Eet_Data_Descriptor *_variant_descriptor;
Eet_Data_Descriptor *_variant_unified_descriptor;
};
typedef struct _data_desc data_desc;
/* Private function */
#define CLOUSEAU_APP_ADD_ENTRY "clouseau/app"
#define CLOUSEAU_TREE_DATA_ENTRY "clouseau/app/tree"
#define CLOUSEAU_BMP_LIST_ENTRY "clouseau/app/shot_list"
#define CLOUSEAU_BMP_DATA_ENTRY "clouseau/app/screenshot"
/* Exported From Object information */
EAPI void clouseau_object_information_free(Clouseau_Object *oinfo);
EAPI Clouseau_Object * clouseau_object_information_get(Clouseau_Tree_Item *treeit);
/* Exported function */
EAPI void clouseau_data_tree_free(Eina_List *tree);
EAPI Clouseau_Message_Type clouseau_data_packet_mapping_type_get(const char *name);
EAPI void clouseau_data_variant_free(Variant_st *v);
EAPI Variant_st *clouseau_data_variant_alloc(Clouseau_Message_Type t, size_t size, void *info);
EAPI void * clouseau_data_packet_compose(Clouseau_Message_Type t, void *data, int data_size, int *size, void *blob, int blob_size);
EAPI Variant_st *
clouseau_data_packet_info_get(void *data, int size);
EAPI void *clouseau_data_packet_compose(const char *p_type, void *data, unsigned int *size, void *blob, int blob_size);
EAPI void *clouseau_data_packet_info_get(const char *p_type, void *data, size_t size);
EAPI void clouseau_data_object_highlight(Evas_Object *obj, Clouseau_Evas_Props *props, bmp_info_st *view);
EAPI Eina_Bool clouseau_data_eet_info_save(const char *filename, app_info_st *a, tree_data_st *ftd, Eina_List *ck_list);
EAPI Eina_Bool clouseau_data_eet_info_read(const char *filename, app_info_st **a, tree_data_st **ftd);
EAPI int clouseau_data_init(void);
EAPI int clouseau_register_descs(Ecore_Con_Eet *eet_svr);
EAPI int clouseau_data_shutdown(void);
#endif /* EET_DATA_H */