void
ecore_con_local_win32_client_del(Ecore_Con_Client *obj)
{
Efl_Network_Client_Data *cl = efl_data_scope_get(obj, EFL_NETWORK_CLIENT_CLASS);
Efl_Network_Server_Data *svr = efl_data_scope_get(cl->host_server, EFL_NETWORK_SERVER_CLASS);
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT)
return;
if (((svr->type & ECORE_CON_TYPE) != ECORE_CON_LOCAL_USER) &&
((svr->type & ECORE_CON_TYPE) != ECORE_CON_LOCAL_SYSTEM))
return;
svr->read_stop = 1;
while (!svr->read_stopped)
Sleep(100);
if (svr->event_peek)
CloseHandle(svr->event_peek);
svr->event_peek = NULL;
if (svr->event_read)
CloseHandle(svr->event_read);
svr->event_read = NULL;
free(svr->path);
svr->path = NULL;
if (svr->pipe)
CloseHandle(svr->pipe);
svr->pipe = NULL;
}
/* thread to read data sent by the server to the client */
static unsigned int __stdcall
_ecore_con_local_win32_client_read_server_thread(void *data)
{
Ecore_Con_Server *obj = data;
Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS);
DWORD nbr_bytes = 0;
svr->read_stopped = EINA_FALSE;
while (!svr->read_stop)
{
if (PeekNamedPipe(svr->pipe, NULL, 0, NULL, &nbr_bytes, NULL))
{
if (nbr_bytes <= 0)
continue;
svr->nbr_bytes = nbr_bytes;
if (!SetEvent(svr->event_read))
continue;
}
else
{
if (GetLastError() == ERROR_BROKEN_PIPE)
{
if (!SetEvent(svr->event_peek))
continue;
break;
}
}
}
svr->read_stopped = EINA_TRUE;
_endthreadex(0);
return 0;
}
void
ecore_con_local_win32_server_del(Ecore_Con_Server *obj)
{
Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS);
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT)
return;
if (((svr->type & ECORE_CON_TYPE) != ECORE_CON_LOCAL_USER) &&
((svr->type & ECORE_CON_TYPE) != ECORE_CON_LOCAL_SYSTEM))
return;
svr->read_stop = 1;
/* FIXME: we should try to stop these thread in one way or another */
/* should we use ecore_thread ? */
/* while (!svr->read_stopped) */
/* Sleep(100); */
if (svr->event_peek)
CloseHandle(svr->event_peek);
svr->event_peek = NULL;
if (svr->event_read)
CloseHandle(svr->event_read);
svr->event_read = NULL;
free(svr->path);
svr->path = NULL;
if (svr->pipe)
CloseHandle(svr->pipe);
svr->pipe = NULL;
}
EAPI void
efl_input_pointer_finalize(Efl_Input_Pointer *obj)
{
const Evas_Pointer_Data *pdata;
Efl_Input_Pointer_Data *ev;
Evas_Public_Data *evas;
Evas *eo_evas;
ev = efl_data_scope_safe_get(obj, MY_CLASS);
EINA_SAFETY_ON_NULL_RETURN(ev);
eo_evas = efl_provider_find(obj, EVAS_CANVAS_CLASS);
evas = efl_data_scope_get(eo_evas, EVAS_CANVAS_CLASS);
if (!evas) return;
/* FIXME: modifiers & locks should be seat-based! */
ev->modifiers = &evas->modifiers;
ev->locks = &evas->locks;
pdata = _evas_pointer_data_by_device_get(evas, ev->device);
if (!pdata) return;
ev->prev.x = pdata->seat->x;
ev->prev.y = pdata->seat->y;
ev->pressed_buttons = pdata->button;
}
EOLIAN static Efl_Input_Event *
_efl_input_pointer_efl_duplicate_duplicate(const Eo *obj, Efl_Input_Pointer_Data *pd)
{
Efl_Input_Pointer_Data *ev;
Efl_Input_Focus *evt;
if (efl_invalidated_get(obj))
{
ERR("Object %s has already been invalidated and can't be duplicated.", efl_debug_name_get(obj));
return NULL;
}
if (!efl_parent_get(obj))
{
ERR("Object %s has not parent during duplicate.", efl_debug_name_get(obj));
return NULL;
}
evt = efl_add(MY_CLASS, efl_parent_get(obj),
efl_allow_parent_unref_set(efl_added, EINA_TRUE));
ev = efl_data_scope_get(evt, MY_CLASS);
if (!ev) return NULL;
memcpy(ev, pd, sizeof(*ev));
ev->eo = evt;
ev->legacy = NULL;
ev->evas_done = 0;
ev->win_fed = 0;
ev->fake = 1;
ev->device = efl_ref(pd->device);
return evt;
}
static Eina_Bool
_ecore_con_local_win32_server_read_client_handler(void *data, Ecore_Win32_Handler *wh)
{
Ecore_Con_Client *obj = data;
Efl_Network_Client_Data *cl = efl_data_scope_get(obj, EFL_NETWORK_CLIENT_CLASS);
void *buf;
DWORD n;
Eina_Bool broken_pipe = EINA_FALSE;
Efl_Network_Server_Data *host_svr = efl_data_scope_get(cl->host_server, EFL_NETWORK_SERVER_CLASS);
if (!ResetEvent(host_svr->event_read))
return ECORE_CALLBACK_RENEW;
buf = malloc(host_svr->nbr_bytes);
if (!buf)
return ECORE_CALLBACK_RENEW;
if (ReadFile(host_svr->pipe, buf, host_svr->nbr_bytes, &n, NULL))
{
if (!cl->delete_me)
ecore_con_event_client_data(obj, buf, host_svr->nbr_bytes, EINA_FALSE);
host_svr->want_write = 1;
}
else
{
if (GetLastError() == ERROR_BROKEN_PIPE)
broken_pipe = EINA_TRUE;
}
if (broken_pipe)
{
#if 0
ecore_con_event_client_error(cl, evil_last_error_get());
#endif
_ecore_con_client_kill(obj);
return ECORE_CALLBACK_CANCEL;
}
if (host_svr->want_write)
ecore_con_local_win32_client_flush(obj);
ecore_main_win32_handler_del(wh);
return ECORE_CALLBACK_DONE;
}
static void
_elm_code_widget_undo_change(Evas_Object *widget,
Elm_Code_Widget_Change_Info *info)
{
Elm_Code_Widget_Data *pd;
unsigned int textlen, position, row, col, newrow, remainlen;
short nllen;
char *content;
Elm_Code_Line *line;
pd = efl_data_scope_get(widget, ELM_CODE_WIDGET_CLASS);
if (info->insert)
{
elm_code_widget_selection_start(widget, info->start_line, info->start_col);
elm_code_widget_selection_end(widget, info->end_line, info->end_col);
_elm_code_widget_selection_delete_no_undo(widget);
}
else
{
newrow = info->start_line;
content = info->content;
remainlen = info->length;
elm_code_widget_selection_clear(widget);
elm_code_widget_cursor_position_set(widget, info->start_line,
info->start_col);
while (newrow <= info->end_line)
{
line = elm_code_file_line_get(pd->code->file, newrow);
if (newrow != info->end_line)
{
textlen = remainlen;
textlen = elm_code_text_newlinenpos(content, remainlen,
&nllen);
remainlen -= textlen + nllen;
_elm_code_widget_text_at_cursor_insert_no_undo(widget,
content,
textlen);
elm_obj_code_widget_cursor_position_get(widget, &row, &col);
position = elm_code_widget_line_text_position_for_column_get(widget, line, col);
elm_code_line_split_at(line, position);
elm_code_widget_cursor_position_set(widget, newrow + 1, 1);
content += textlen + nllen;
}
else
{
_elm_code_widget_text_at_cursor_insert_no_undo(widget,
content,
strlen(content));
}
newrow++;
}
elm_code_widget_cursor_position_set(widget, info->end_line,
info->end_col + 1);
}
efl_event_callback_legacy_call(widget, ELM_OBJ_CODE_WIDGET_EVENT_CHANGED_USER, NULL);
}
Eina_Bool
ecore_con_local_win32_client_flush(Ecore_Con_Client *obj)
{
Efl_Network_Client_Data *cl = efl_data_scope_get(obj, EFL_NETWORK_CLIENT_CLASS);
Ecore_Con_Type type;
size_t num;
BOOL res;
DWORD written;
Efl_Network_Server_Data *svr = efl_data_scope_get(cl->host_server, EFL_NETWORK_SERVER_CLASS);
type = svr->type & ECORE_CON_TYPE;
/* This check should never be true */
if (type == ECORE_CON_LOCAL_ABSTRACT)
return EINA_TRUE;
if ((type != ECORE_CON_LOCAL_USER) &&
(type != ECORE_CON_LOCAL_SYSTEM))
return EINA_FALSE;
num = eina_binbuf_length_get(cl->buf) - cl->buf_offset;
if (num == 0) return EINA_TRUE;
res = WriteFile(svr->pipe, eina_binbuf_string_get(cl->buf) + cl->buf_offset, num, &written, NULL);
if (!res)
{
ecore_con_event_client_error(obj, evil_last_error_get());
_ecore_con_client_kill(obj);
}
cl->buf_offset += written;
if (cl->buf_offset >= eina_binbuf_length_get(cl->buf))
{
cl->buf_offset = 0;
eina_binbuf_free(cl->buf);
cl->buf = NULL;
svr->want_write = 0;
}
else if (written < (DWORD)num)
svr->want_write = 1;
return EINA_TRUE;
}
static void
_efl_net_control_technology_property_changed(void *data, const Eldbus_Message *msg)
{
Eo *o = data;
Efl_Net_Control_Technology_Data *pd = efl_data_scope_get(o, MY_CLASS);
Eldbus_Message_Iter *itr;
itr = eldbus_message_iter_get(msg);
_efl_net_control_technology_property_changed_internal(o, pd, itr);
}
EOLIAN static void
_efl_canvas_surface_wayland_efl_object_destructor(Eo *eo, Efl_Canvas_Surface_Wayland_Data *pd)
{
Evas_Object_Protected_Data *obj;
obj = efl_data_scope_get(eo, EFL_CANVAS_OBJECT_CLASS);
ENFN->image_native_shutdown(ENDT, EVAS_NATIVE_SURFACE_WL);
efl_data_unref(eo, pd->base);
efl_destructor(eo);
}
EOLIAN static void
_efl_canvas_vg_object_root_node_set(Eo *eo_obj, Efl_Canvas_Vg_Object_Data *pd, Efl_VG *root_node)
{
// if the same root is already set
if (pd->user_entry && pd->user_entry->root == root_node)
return;
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
// check if a file has been already set
if (pd->vg_entry)
{
evas_cache_vg_entry_del(pd->vg_entry);
pd->vg_entry = NULL;
}
// detach/free the old root_node
if (pd->user_entry && pd->user_entry->root)
{
efl_canvas_vg_node_vg_obj_set(pd->user_entry->root, NULL, NULL);
efl_parent_set(pd->user_entry->root, NULL);
}
if (root_node)
{
if (!pd->user_entry)
{
pd->user_entry = malloc(sizeof(Vg_User_Entry));
if (!pd->user_entry)
{
ERR("Failed to alloc user entry data while setting root node");
return;
}
}
pd->user_entry->w = pd->user_entry->h = 0;
pd->user_entry->root = root_node;
// set the parent so that vg canvas can render it.
efl_parent_set(pd->user_entry->root, pd->root);
efl_canvas_vg_node_vg_obj_set(root_node, eo_obj, pd);
}
else if (pd->user_entry)
{
// drop any surface cache attached to it.
ENFN->ector_surface_cache_drop(_evas_engine_context(obj->layer->evas), pd->user_entry->root);
free(pd->user_entry);
pd->user_entry = NULL;
}
// force a redraw
pd->changed = EINA_TRUE;
evas_object_change(eo_obj, obj);
}
int
main(int argc, char *argv[])
{
(void) argc;
(void) argv;
efl_object_init();
Eo *obj = efl_add(SIMPLE_CLASS, NULL);
simple_a_set(obj, 1);
simple_b_set(obj, 2);
int a = 0, b = 0, sum = 0;
a = simple_a_get(obj);
b = simple_b_get(obj);
sum = mixin_ab_sum_get(obj);
fail_if(sum != a + b + 2); /* 2 for the two mixins... */
sum = mixin_ab_sum_get(obj);
sum = mixin_ab_sum_get(obj);
Mixin2_Public_Data *pd2 = efl_data_scope_get(obj, MIXIN2_CLASS);
fail_if(pd2->count != 6);
Mixin3_Public_Data *pd3 = efl_data_scope_get(obj, MIXIN3_CLASS);
fail_if(pd3->count != 9);
efl_unref(obj);
obj = efl_add(INHERIT_CLASS, NULL);
simple_a_set(obj, 5);
a = simple_a_get(obj);
printf("%d\n", a);
fail_if(a != 5);
efl_unref(obj);
efl_object_shutdown();
return 0;
}
static Eina_Bool
_ecore_con_local_win32_server_peek_client_handler(void *data, Ecore_Win32_Handler *wh)
{
Ecore_Con_Client *obj = data;
Efl_Network_Client_Data *cl = efl_data_scope_get(obj, EFL_NETWORK_CLIENT_CLASS);
Efl_Network_Server_Data *host_svr = efl_data_scope_get(cl->host_server, EFL_NETWORK_SERVER_CLASS);
#if 0
char *msg;
#endif
if (!ResetEvent(host_svr->event_peek))
return ECORE_CALLBACK_RENEW;
#if 0
ecore_con_event_server_error(host_svr, evil_last_error_get());
#endif
_ecore_con_server_kill(cl->host_server);
return ECORE_CALLBACK_CANCEL;
ecore_main_win32_handler_del(wh);
return ECORE_CALLBACK_DONE;
}
static void
_efl_net_control_technology_property_set_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
Eo *o = data;
Efl_Net_Control_Technology_Data *pd = efl_data_scope_get(o, MY_CLASS);
const char *err_name, *err_msg;
pd->pending = eina_list_remove(pd->pending, pending);
if (eldbus_message_error_get(msg, &err_name, &err_msg))
{
ERR("Could not set property %p: %s=%s", o, err_name, err_msg);
return;
}
}
/* internal eo */
EOAPI Eo*
efl_input_pointer_instance_get(Efl_Object *owner, void **priv)
{
Efl_Input_Pointer_Data *ev;
Efl_Input_Pointer *evt;
evt = efl_input_event_instance_get(EFL_INPUT_POINTER_CLASS, owner);
if (!evt) return NULL;
ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
ev->fake = EINA_FALSE;
if (priv) *priv = ev;
return evt;
}
void
_elm_code_widget_undo_change_add(Evas_Object *widget,
Elm_Code_Widget_Change_Info *info)
{
Elm_Code_Widget_Data *pd;
Elm_Code_Widget_Change_Info *info_copy;
info_copy = _elm_code_widget_undo_info_copy(info);
pd = efl_data_scope_get(widget, ELM_CODE_WIDGET_CLASS);
_elm_code_widget_undo_prev_clear(widget);
pd->undo_stack_ptr = eina_list_prepend(pd->undo_stack_ptr, info_copy);
pd->undo_stack = pd->undo_stack_ptr;
}
Efl_Net_Socket_Windows_Operation *
_efl_net_socket_windows_operation_new(Eo *o, Efl_Net_Socket_Windows_Operation_Success_Cb success_cb, Efl_Net_Socket_Windows_Operation_Failure_Cb failure_cb, const void *data)
{
Efl_Net_Socket_Windows_Operation *op;
Efl_Net_Socket_Windows_Data *pd = efl_data_scope_get(o, EFL_NET_SOCKET_WINDOWS_CLASS);
EINA_SAFETY_ON_NULL_RETURN_VAL(pd, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(success_cb, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(failure_cb, NULL);
op = calloc(1, sizeof(*op));
EINA_SAFETY_ON_NULL_RETURN_VAL(op, NULL);
op->base.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!op->base.hEvent)
{
char *msg = _efl_net_windows_error_msg_get(GetLastError());
ERR("socket=%p success_cb=%p failure_cb=%p data=%p: error=%s",
op->o, op->success_cb, op->failure_cb, op->data, msg);
free(msg);
goto error_event;
}
op->event_handler = ecore_main_win32_handler_add(op->base.hEvent, _efl_net_socket_windows_operation_event, op);
if (!op->event_handler)
{
ERR("socket=%p success_cb=%p failure_cb=%p data=%p: could not create event handler",
op->o, op->success_cb, op->failure_cb, op->data);
goto error_handler;
}
op->success_cb = success_cb;
op->failure_cb = failure_cb;
op->data = data;
op->o = o;
pd->pending_ops = eina_list_append(pd->pending_ops, op);
DBG("op=%p (socket=%p) success_cb=%p failure_cb=%p data=%p",
op, op->o, op->success_cb, op->failure_cb, op->data);
return op;
error_handler:
CloseHandle(op->base.hEvent);
error_event:
free(op);
return NULL;
}
static void
_node_change(Efl_VG *obj, Efl_Canvas_Vg_Node_Data *nd)
{
if (!nd || nd->flags != EFL_GFX_CHANGE_FLAG_NONE) return;
nd->flags = EFL_GFX_CHANGE_FLAG_ALL;
Eo *p = obj;
while ((p = efl_parent_get(p)))
{
if (!efl_isa(p, MY_CLASS)) break;
Efl_Canvas_Vg_Node_Data *pnd = efl_data_scope_get(p, MY_CLASS);
if (pnd->flags != EFL_GFX_CHANGE_FLAG_NONE) break;
pnd->flags = EFL_GFX_CHANGE_FLAG_ALL;
}
if (efl_invalidated_get(nd->vg_obj)) return;
efl_canvas_vg_object_change(nd->vd);
}
static void
_edje_mouse_out_signal_cb(void *data, const Efl_Event *event)
{
Efl_Input_Pointer_Data *ev;
Edje *ed;
Edje_Real_Part *rp;
ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
ed = data;
rp = evas_object_data_get(event->object, "real_part");
if (rp)
{
if (!(ev->event_flags) || !(rp->ignore_flags & ev->event_flags))
_edje_seat_emit(ed, ev->device, "mouse,out", rp->part->name);
ev->event_flags |= rp->mask_flags;
}
}
static void
_elm_code_widget_undo_prev_clear(Evas_Object *widget)
{
Elm_Code_Widget_Data *pd;
Elm_Code_Widget_Change_Info *info;
Eina_List *list;
pd = efl_data_scope_get(widget, ELM_CODE_WIDGET_CLASS);
if (!pd->undo_stack_ptr)
return;
for (list = eina_list_prev(pd->undo_stack_ptr); list; list = eina_list_prev(list))
{
info = eina_list_data_get(list);
free(info->content);
free(info);
}
}
static void
_set_material_to_mesh_from_eet_file(Evas_Canvas3D_Mesh *mesh,
Evas_Canvas3D_Mesh_Eet *eet_mesh)
{
Evas_Canvas3D_Object_Data *pd = efl_data_scope_get(mesh, EVAS_CANVAS3D_OBJECT_CLASS);
Eo *material = NULL;
material = efl_add(EVAS_CANVAS3D_MATERIAL_CLASS, pd->evas);
evas_canvas3d_material_enable_set(material, EVAS_CANVAS3D_MATERIAL_ATTRIB_AMBIENT, !!(eet_mesh->materials->colors[0].a > 0));
evas_canvas3d_material_enable_set(material, EVAS_CANVAS3D_MATERIAL_ATTRIB_DIFFUSE, !!(eet_mesh->materials->colors[1].a > 0));
evas_canvas3d_material_enable_set(material, EVAS_CANVAS3D_MATERIAL_ATTRIB_SPECULAR, !!(eet_mesh->materials->colors[2].a > 0));
evas_canvas3d_material_enable_set(material, EVAS_CANVAS3D_MATERIAL_ATTRIB_NORMAL, EINA_TRUE);
evas_canvas3d_material_color_set(material, EVAS_CANVAS3D_MATERIAL_ATTRIB_AMBIENT, eet_mesh->materials->colors[0].r, eet_mesh->materials->colors[0].g, eet_mesh->materials->colors[0].b, eet_mesh->materials->colors[0].a);
evas_canvas3d_material_color_set(material, EVAS_CANVAS3D_MATERIAL_ATTRIB_DIFFUSE, eet_mesh->materials->colors[1].r, eet_mesh->materials->colors[1].g, eet_mesh->materials->colors[1].b, eet_mesh->materials->colors[1].a);
evas_canvas3d_material_color_set(material, EVAS_CANVAS3D_MATERIAL_ATTRIB_SPECULAR, eet_mesh->materials->colors[2].r, eet_mesh->materials->colors[2].g, eet_mesh->materials->colors[2].b, eet_mesh->materials->colors[2].a);
evas_canvas3d_material_shininess_set(material, eet_mesh->materials->shininess);
evas_canvas3d_mesh_frame_material_set(mesh, 0, material);
}
EOLIAN static Eo *
_efl_canvas_surface_wayland_efl_object_constructor(Eo *eo, Efl_Canvas_Surface_Wayland_Data *pd)
{
Evas_Object_Protected_Data *obj;
eo = efl_constructor(efl_super(eo, MY_CLASS));
obj = efl_data_scope_get(eo, EFL_CANVAS_OBJECT_CLASS);
if (!obj) return NULL;
if (!ENFN->image_native_init(ENDT, EVAS_NATIVE_SURFACE_WL))
{
ERR("Wayland surfaces are not supported on this platform");
return NULL;
}
pd->base = efl_data_ref(eo, EFL_CANVAS_SURFACE_MIXIN);
pd->base->surf.type = EVAS_NATIVE_SURFACE_WL;
return eo;
}
static void
_update_vgtree_viewport(Eo *obj, Efl_Canvas_Vg_Object_Data *pd)
{
double vb_w, vb_h, vp_w, vp_h, scale_w, scale_h, scale;
Eina_Size2D sz = efl_gfx_entity_size_get(obj);
Eina_Matrix3 m;
eina_matrix3_identity(&m);
vb_w = pd->viewbox.w;
vb_h = pd->viewbox.h;
vp_w = sz.w;
vp_h = sz.h;
scale_w = vp_w / vb_w;
scale_h = vp_h / vb_h;
if (pd->fill_mode == EFL_CANVAS_VG_FILL_MODE_STRETCH)
{ // Fill the viewport and ignore the aspect ratio
eina_matrix3_scale(&m, scale_w, scale_h);
eina_matrix3_translate(&m, -pd->viewbox.x, -pd->viewbox.y);
}
else
{
if (pd->fill_mode == EFL_CANVAS_VG_FILL_MODE_MEET)
scale = scale_w < scale_h ? scale_w : scale_h;
else // slice
scale = scale_w > scale_h ? scale_w : scale_h;
eina_matrix3_translate(&m, (vp_w - vb_w * scale) * pd->align_x, (vp_h - vb_h * scale) * pd->align_y);
eina_matrix3_scale(&m, scale, scale);
eina_matrix3_translate(&m, -pd->viewbox.x, -pd->viewbox.y);
}
efl_canvas_vg_node_transformation_set(pd->root, &m);
pd->changed = EINA_TRUE;
evas_object_change(obj, efl_data_scope_get(obj, EFL_CANVAS_OBJECT_CLASS));
}
static void
_edje_mouse_wheel_signal_cb(void *data, const Efl_Event *event)
{
Efl_Input_Pointer_Data *ev;
Edje *ed;
Edje_Real_Part *rp;
char buf[256];
ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
ed = data;
rp = evas_object_data_get(event->object, "real_part");
if (rp)
{
if (!(ev->event_flags) || !(rp->ignore_flags & ev->event_flags))
{
snprintf(buf, sizeof(buf), "mouse,wheel,%i,%i",
ev->wheel.horizontal,
(ev->wheel.z < 0) ? (-1) : (1));
_edje_seat_emit(ed, ev->device, buf, rp->part->name);
}
ev->event_flags |= rp->mask_flags;
}
}
static unsigned int __stdcall
_ecore_con_local_win32_listening(void *data)
{
Ecore_Con_Server *obj = data;
Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS);
BOOL res;
while (1)
{
res = ConnectNamedPipe(svr->pipe, NULL);
if (!res)
{
ERR("Opening the connection to the client failed");
CloseHandle(svr->pipe);
svr->pipe = NULL;
}
break;
}
DBG("Client connected");
_endthreadex(0);
return 0;
}
#define MY_CLASS ELM_BOX_CLASS
#define MY_CLASS_NAME "Elm_Box"
#define MY_CLASS_NAME_LEGACY "elm_box"
static const char SIG_CHILD_ADDED[] = "child,added";
static const char SIG_CHILD_REMOVED[] = "child,removed";
static const Evas_Smart_Cb_Description _smart_callbacks[] = {
{SIG_CHILD_ADDED, ""},
{SIG_CHILD_REMOVED, ""},
{NULL, NULL}
};
static void
_focus_order_flush(Eo *obj, Elm_Box_Data *pd EINA_UNUSED)
{
Elm_Widget_Smart_Data *wpd = efl_data_scope_get(obj, ELM_WIDGET_CLASS);
Eina_List *order = evas_object_box_children_get(wpd->resize_obj);
efl_ui_focus_manager_update_order(wpd->focus.manager, obj, order);
}
static void *
_elm_box_list_data_get(const Eina_List *list)
{
Evas_Object_Box_Option *opt = eina_list_data_get(list);
return opt->obj;
}
static void
_child_added_cb_proxy(void *data, const Efl_Event *event)
{
Eina_Bool
ecore_con_local_connect(Ecore_Con_Server *obj,
Eina_Bool (*cb_done)(void *data,
Ecore_Fd_Handler *fd_handler))
{
#warning "I am pretty sure cb_done should be used."
Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS);
char *buf = NULL;
Ecore_Win32_Handler *handler_read;
Ecore_Win32_Handler *handler_peek;
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT)
{
WRN("Your system does not support abstract sockets!");
return EINA_FALSE;
}
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_USER)
buf = ecore_con_local_path_new(EINA_FALSE, svr->name, svr->port);
else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_SYSTEM)
buf = ecore_con_local_path_new(EINA_TRUE, svr->name, svr->port);
EINA_SAFETY_ON_NULL_RETURN_VAL(buf, EINA_FALSE);
while (1)
{
svr->pipe = CreateFile(buf,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
if (svr->pipe != INVALID_HANDLE_VALUE)
break;
/* if pipe not busy, we exit */
if (GetLastError() != ERROR_PIPE_BUSY)
{
DBG("Connection to a server failed");
free(buf);
return EINA_FALSE;
}
/* pipe busy, so we wait for it */
if (!WaitNamedPipe(buf, NMPWAIT_WAIT_FOREVER))
{
DBG("Can not wait for a server");
goto close_pipe;
}
}
svr->path = buf;
buf = NULL;
svr->event_read = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!svr->event_read)
{
ERR("Can not create event read");
goto free_path;
}
handler_read = ecore_main_win32_handler_add(svr->event_read,
_ecore_con_local_win32_client_read_server_handler,
obj);
if (!handler_read)
{
ERR("Can not create handler read");
goto close_event_read;
}
svr->event_peek = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!svr->event_peek)
{
ERR("Can not create event peek");
goto del_handler_read;
}
handler_peek = ecore_main_win32_handler_add(svr->event_peek,
_ecore_con_local_win32_client_peek_server_handler,
obj);
if (!handler_peek)
{
ERR("Can not create handler peek");
goto close_event_peek;
}
svr->thread_read = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_client_read_server_thread, obj, CREATE_SUSPENDED, NULL);
if (!svr->thread_read)
{
ERR("Can not launch thread");
goto del_handler_peek;
}
if (!svr->delete_me) ecore_con_event_server_add(obj);
ResumeThread(svr->thread_read);
free(buf);
return EINA_TRUE;
del_handler_peek:
ecore_main_win32_handler_del(handler_peek);
close_event_peek:
CloseHandle(svr->event_peek);
del_handler_read:
ecore_main_win32_handler_del(handler_read);
close_event_read:
CloseHandle(svr->event_read);
free_path:
free(svr->path);
svr->path = NULL;
close_pipe:
CloseHandle(svr->pipe);
free(buf);
return EINA_FALSE;
}
Eina_Bool
ecore_con_local_listen(Ecore_Con_Server *obj)
{
Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS);
HANDLE thread_listening;
Ecore_Win32_Handler *handler;
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT)
{
ERR("Your system does not support abstract sockets!");
return EINA_FALSE;
}
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_USER)
svr->path = ecore_con_local_path_new(EINA_FALSE, svr->name, svr->port);
else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_SYSTEM)
svr->path = ecore_con_local_path_new(EINA_TRUE, svr->name, svr->port);
if (!svr->path)
{
ERR("Allocation failed");
return EINA_FALSE;
}
/*
* synchronuous
* block mode
* wait mode
*/
svr->pipe = CreateNamedPipe(svr->path,
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,
BUFSIZE,
BUFSIZE,
5000,
NULL);
if (svr->pipe == INVALID_HANDLE_VALUE)
{
DBG("Creation of the named pipe '%s' failed", svr->path);
goto free_path;
}
/*
* We use ConnectNamedPipe() to wait for a client to connect.
* As the function is blocking, to let the main loop continuing
* its iterations, we call ConnectNamedPipe() in a thread
*/
thread_listening = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_listening, obj, CREATE_SUSPENDED, NULL);
if (!thread_listening)
{
ERR("Creation of the listening thread failed");
goto close_pipe;
}
handler = ecore_main_win32_handler_add(thread_listening,
_ecore_con_local_win32_client_add,
obj);
if (!handler)
{
ERR("Creation of the client add handler failed");
goto del_handler;
}
svr->read_stopped = EINA_TRUE;
ResumeThread(thread_listening);
return EINA_TRUE;
del_handler:
ecore_main_win32_handler_del(handler);
close_pipe:
CloseHandle(svr->pipe);
free_path:
free(svr->path);
svr->path = NULL;
return EINA_FALSE;
}
static Eina_Bool
_ecore_con_local_win32_client_add(void *data, Ecore_Win32_Handler *wh)
{
Ecore_Con_Server *obj = data;
Efl_Network_Server_Data *svr = efl_data_scope_get(obj, EFL_NETWORK_SERVER_CLASS);
Ecore_Win32_Handler *handler_read;
Ecore_Win32_Handler *handler_peek;
if (!svr->pipe)
return ECORE_CALLBACK_CANCEL;
if (svr->delete_me)
return ECORE_CALLBACK_CANCEL;
if ((svr->client_limit >= 0) && (!svr->reject_excess_clients) &&
(svr->client_count >= (unsigned int)svr->client_limit))
return ECORE_CALLBACK_CANCEL;
Ecore_Con_Client *cl_obj = efl_add(EFL_NETWORK_CLIENT_CLASS, efl_main_loop_get());
Efl_Network_Client_Data *cl = efl_data_scope_get(obj, EFL_NETWORK_CLIENT_CLASS);
if (!cl)
{
ERR("allocation failed");
return ECORE_CALLBACK_CANCEL;
}
cl->host_server = obj;
svr->event_read = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!svr->event_read)
{
ERR("Can not create event read");
goto free_cl;
}
handler_read = ecore_main_win32_handler_add(svr->event_read,
_ecore_con_local_win32_server_read_client_handler,
obj);
if (!handler_read)
{
ERR("Can not create handler read");
goto close_event_read;
}
svr->event_peek = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!svr->event_peek)
{
ERR("Can not create event peek");
goto del_handler_read;
}
handler_peek = ecore_main_win32_handler_add(svr->event_peek,
_ecore_con_local_win32_server_peek_client_handler,
obj);
if (!handler_peek)
{
ERR("Can not create handler peek");
goto close_event_peek;
}
svr->read_stopped = EINA_TRUE;
svr->thread_read = (HANDLE)_beginthreadex(NULL, 0, _ecore_con_local_win32_server_read_client_thread, cl, CREATE_SUSPENDED, NULL);
if (!svr->thread_read)
{
ERR("Can not launch thread");
goto del_handler_peek;
}
svr->clients = eina_list_append(svr->clients, obj);
svr->client_count++;
if (!cl->delete_me)
ecore_con_event_client_add(obj);
ecore_main_win32_handler_del(wh);
ResumeThread(svr->thread_read);
return ECORE_CALLBACK_DONE;
del_handler_peek:
ecore_main_win32_handler_del(handler_peek);
close_event_peek:
CloseHandle(svr->event_peek);
del_handler_read:
ecore_main_win32_handler_del(handler_read);
close_event_read:
CloseHandle(svr->event_read);
free_cl:
efl_del(cl_obj);
return ECORE_CALLBACK_CANCEL;
}
else if (exit_code == 128) err = EINVAL;
else if (exit_code == 129) err = EFAULT;
else if (exit_code == 130) err = EINTR;
else if ((exit_code >= 131) && (exit_code <= 165)) err = EFAULT;
eina_promise_reject(p, err);
}
else eina_promise_resolve(p, eina_value_int_init(exit_code));
}
}
}
static void
_cb_exe_exit_read(void *data, const Efl_Event *event EINA_UNUSED)
{
Eo *obj = data;
Efl_Exe_Data *pd = efl_data_scope_get(obj, MY_CLASS);
Ecore_Signal_Pid_Info pinfo;
if (!pd) return;
if (read(pd->fd.exited_read, &pinfo, sizeof(Ecore_Signal_Pid_Info)) ==
sizeof(Ecore_Signal_Pid_Info))
{
Efl_Task_Data *td = efl_data_scope_get(obj, EFL_TASK_CLASS);
if (td)
{
td->exited = EINA_TRUE;
td->exit_code = pinfo.exit_code;
pd->exit_signal = pinfo.exit_signal;
}
}
// we don't need this fd and handler anymore now we code exit status
