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