1 #include "ecore_evas_extn_engine.h"
2
3 #ifdef EAPI
4 # undef EAPI
5 #endif
6
7 #ifdef _WIN32
8 # ifdef DLL_EXPORT
9 # define EAPI __declspec(dllexport)
10 # else
11 # define EAPI
12 # endif /* ! DLL_EXPORT */
13 #else
14 # ifdef __GNUC__
15 # if __GNUC__ >= 4
16 # define EAPI __attribute__ ((visibility("default")))
17 # else
18 # define EAPI
19 # endif
20 # else
21 # define EAPI
22 # endif
23 #endif /* ! _WIN32 */
24
25 #define NBUF 2
26
27 static int blank = 0x00000000;
28 static const char *interface_extn_name = "extn";
29 static const int interface_extn_version = 1;
30 static Ecore_Evas_Interface_Extn *_ecore_evas_extn_interface_new(void);
31 static void *_ecore_evas_socket_switch(void *data, void *dest_buf);
32
33 typedef struct _Extn Extn;
34
35 struct _Extn
36 {
37 struct {
38 Ecore_Ipc_Server *server;
39 Eina_List *clients;
40 Eina_List *visible_clients;
41 Eina_List *handlers;
42 } ipc;
43 struct {
44 const char *name;
45 int num;
46 Eina_Bool sys : 1;
47 } svc;
48 struct {
49 Eina_List *updates;
50 } file;
51 struct {
52 Extnbuf *buf, *obuf; // current buffer and if needed an "old" buffer
53 const char *base, *lock;
54 int id, num, w, h;
55 Eina_Bool sys : 1;
56 Eina_Bool alpha : 1;
57 } b[NBUF];
58 int cur_b; // current buffer (b) being displayed or rendered to
59 int prev_b; // the last buffer (b) that was rendered
60 struct {
61 Eina_Bool done : 1; /* need to send change done event to the client(plug) */
62 } profile;
63 };
64
65 static Eina_List *extn_ee_list = NULL;
66
67 static Eina_Bool
_ecore_evas_extn_module_init(void)68 _ecore_evas_extn_module_init(void)
69 {
70 return EINA_TRUE;
71 }
72
73 static void
_ecore_evas_extn_module_shutdown(void)74 _ecore_evas_extn_module_shutdown(void)
75 {
76 }
77
78 static void
_ecore_evas_extn_event_free(void * data,void * ev EINA_UNUSED)79 _ecore_evas_extn_event_free(void *data, void *ev EINA_UNUSED)
80 {
81 Ecore_Evas *ee = data;
82 _ecore_evas_unref(ee);
83 }
84
85 static void
_ecore_evas_extn_event(Ecore_Evas * ee,int event)86 _ecore_evas_extn_event(Ecore_Evas *ee, int event)
87 {
88 _ecore_evas_ref(ee);
89 ecore_event_add(event, ee, _ecore_evas_extn_event_free, ee);
90 }
91
92 static void
_ecore_evas_extn_plug_render_pre(void * data,Evas * e EINA_UNUSED,void * event_info EINA_UNUSED)93 _ecore_evas_extn_plug_render_pre(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
94 {
95 Ecore_Evas *ee = data;
96 Ecore_Evas_Engine_Buffer_Data *bdata;
97 Extn *extn;
98
99 if (!ee) return;
100 bdata = ee->engine.data;
101 if (!bdata) return;
102 extn = bdata->data;
103 if (!extn) return;
104 bdata->pixels = _extnbuf_lock(extn->b[extn->cur_b].buf, NULL, NULL, NULL);
105 }
106
107 static void
_ecore_evas_extn_plug_render_post(void * data,Evas * e EINA_UNUSED,void * event_info EINA_UNUSED)108 _ecore_evas_extn_plug_render_post(void *data, Evas *e EINA_UNUSED, void *event_info EINA_UNUSED)
109 {
110 Ecore_Evas *ee = data;
111 Ecore_Evas_Engine_Buffer_Data *bdata;
112 Extn *extn;
113
114 if (!ee) return;
115 bdata = ee->engine.data;
116 if (!bdata) return;
117 extn = bdata->data;
118 if (!extn) return;
119 _extnbuf_unlock(extn->b[extn->cur_b].buf);
120 if (extn->b[extn->cur_b].obuf)
121 {
122 _extnbuf_unlock(extn->b[extn->cur_b].obuf);
123 _extnbuf_free(extn->b[extn->cur_b].obuf);
124 extn->b[extn->cur_b].obuf = NULL;
125 }
126 }
127
128 static void
_ecore_evas_extn_plug_image_obj_del(void * data,Evas * e EINA_UNUSED,Evas_Object * obj EINA_UNUSED,void * event_info EINA_UNUSED)129 _ecore_evas_extn_plug_image_obj_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
130 {
131 Ecore_Evas *ee = data;
132 ecore_evas_free(ee);
133 }
134
135 static void
_ecore_evas_extn_coord_translate(Ecore_Evas * ee,Evas_Coord * x,Evas_Coord * y)136 _ecore_evas_extn_coord_translate(Ecore_Evas *ee, Evas_Coord *x, Evas_Coord *y)
137 {
138 Evas_Coord xx, yy, ww, hh, fx, fy, fw, fh;
139 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
140
141 evas_object_geometry_get(bdata->image, &xx, &yy, &ww, &hh);
142 evas_object_image_fill_get(bdata->image, &fx, &fy, &fw, &fh);
143
144 if (fw < 1) fw = 1;
145 if (fh < 1) fh = 1;
146
147 if (evas_object_map_get(bdata->image) &&
148 evas_object_map_enable_get(bdata->image))
149 {
150 fx = 0; fy = 0;
151 fw = ee->w; fh = ee->h;
152 ww = ee->w; hh = ee->h;
153 }
154
155 if ((fx == 0) && (fy == 0) && (fw == ww) && (fh == hh))
156 {
157 *x = (ee->w * (*x - xx)) / fw;
158 *y = (ee->h * (*y - yy)) / fh;
159 }
160 else
161 {
162 xx = (*x - xx) - fx;
163 while (xx < 0) xx += fw;
164 while (xx > fw) xx -= fw;
165 *x = (ee->w * xx) / fw;
166
167 yy = (*y - yy) - fy;
168 while (yy < 0) yy += fh;
169 while (yy > fh) yy -= fh;
170 *y = (ee->h * yy) / fh;
171 }
172 }
173
174 static void
_ecore_evas_extn_free(Ecore_Evas * ee)175 _ecore_evas_extn_free(Ecore_Evas *ee)
176 {
177 Extn *extn;
178 Ecore_Ipc_Client *client;
179 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
180 if (!bdata) return;
181
182 extn = bdata->data;
183 if (extn)
184 {
185 Ecore_Event_Handler *hdl;
186 Ipc_Data_Update *ipc;
187 int i;
188 if (bdata->image)
189 {
190 evas_object_image_data_set(bdata->image, NULL);
191 evas_object_image_pixels_dirty_set(bdata->image, EINA_TRUE);
192 }
193 bdata->pixels = NULL;
194 for (i = 0; i < NBUF; i++)
195 {
196 if (extn->b[i].buf) _extnbuf_free(extn->b[i].buf);
197 if (extn->b[i].obuf) _extnbuf_free(extn->b[i].obuf);
198 if (extn->b[i].base) eina_stringshare_del(extn->b[i].base);
199 if (extn->b[i].lock) eina_stringshare_del(extn->b[i].lock);
200 extn->b[i].buf = NULL;
201 extn->b[i].obuf = NULL;
202 extn->b[i].base = NULL;
203 extn->b[i].lock = NULL;
204 }
205 if (extn->svc.name) eina_stringshare_del(extn->svc.name);
206 if (extn->ipc.clients)
207 {
208 EINA_LIST_FREE(extn->ipc.clients, client)
209 ecore_ipc_client_del(client);
210 }
211 if (extn->ipc.server) ecore_ipc_server_del(extn->ipc.server);
212 if (extn->ipc.visible_clients) eina_list_free(extn->ipc.visible_clients);
213
214 EINA_LIST_FREE(extn->file.updates, ipc)
215 free(ipc);
216
217 EINA_LIST_FREE(extn->ipc.handlers, hdl)
218 ecore_event_handler_del(hdl);
219 free(extn);
220 ecore_ipc_shutdown();
221 bdata->data = NULL;
222 }
223 if (bdata->image)
224 {
225 Ecore_Evas *ee2;
226
227 evas_object_event_callback_del_full(bdata->image,
228 EVAS_CALLBACK_DEL,
229 _ecore_evas_extn_plug_image_obj_del,
230 ee);
231 evas_event_callback_del_full(evas_object_evas_get(bdata->image),
232 EVAS_CALLBACK_RENDER_PRE,
233 _ecore_evas_extn_plug_render_pre,
234 ee);
235 evas_event_callback_del_full(evas_object_evas_get(bdata->image),
236 EVAS_CALLBACK_RENDER_POST,
237 _ecore_evas_extn_plug_render_post,
238 ee);
239 ee2 = evas_object_data_get(bdata->image, "Ecore_Evas_Parent");
240 if (ee2)
241 {
242 ee2->sub_ecore_evas = eina_list_remove(ee2->sub_ecore_evas, ee);
243 }
244 evas_object_del(bdata->image);
245 bdata->image = NULL;
246 }
247 free(bdata);
248 ee->engine.data = NULL;
249 extn_ee_list = eina_list_remove(extn_ee_list, ee);
250 }
251
252 static void
_ecore_evas_resize(Ecore_Evas * ee,int w,int h)253 _ecore_evas_resize(Ecore_Evas *ee, int w, int h)
254 {
255 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
256
257 if (w < 1) w = 1;
258 if (h < 1) h = 1;
259 ee->req.w = w;
260 ee->req.h = h;
261 if ((w == ee->w) && (h == ee->h)) return;
262 ee->w = w;
263 ee->h = h;
264
265 /*
266 * No need for it if not used later.
267 Extn *extn;
268
269 extn = bdata->data;
270 */
271 if (bdata->image)
272 evas_object_image_size_set(bdata->image, ee->w, ee->h);
273 /* Server can have many plugs, so I block resize comand from client to server *
274 if ((extn) && (extn->ipc.server))
275 {
276 Ipc_Data_Resize ipc;
277
278 ipc.w = ee->w;
279 ipc.h = ee->h;
280 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_RESIZE, 0, 0, 0, &ipc, sizeof(ipc));
281 }*/
282 if (ee->func.fn_resize) ee->func.fn_resize(ee);
283 }
284
285 static void
_ecore_evas_move_resize(Ecore_Evas * ee,int x EINA_UNUSED,int y EINA_UNUSED,int w,int h)286 _ecore_evas_move_resize(Ecore_Evas *ee, int x EINA_UNUSED, int y EINA_UNUSED, int w, int h)
287 {
288 _ecore_evas_resize(ee, w, h);
289 }
290
291 static int
_ecore_evas_modifiers_locks_mask_get(Evas * e)292 _ecore_evas_modifiers_locks_mask_get(Evas *e)
293 {
294 int mask = 0;
295
296 if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Shift"))
297 mask |= MOD_SHIFT;
298 if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Control"))
299 mask |= MOD_CTRL;
300 if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Alt"))
301 mask |= MOD_ALT;
302 if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Meta"))
303 mask |= MOD_META;
304 if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Hyper"))
305 mask |= MOD_HYPER;
306 if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Super"))
307 mask |= MOD_SUPER;
308 if (evas_key_lock_is_set(evas_key_lock_get(e), "Scroll_Lock"))
309 mask |= MOD_SCROLL;
310 if (evas_key_lock_is_set(evas_key_lock_get(e), "Num_Lock"))
311 mask |= MOD_NUM;
312 if (evas_key_lock_is_set(evas_key_lock_get(e), "Caps_Lock"))
313 mask |= MOD_CAPS;
314 return mask;
315 }
316
317 static void
_ecore_evas_modifiers_locks_mask_set(Evas * e,int mask)318 _ecore_evas_modifiers_locks_mask_set(Evas *e, int mask)
319 {
320 if (mask & MOD_SHIFT) evas_key_modifier_on (e, "Shift");
321 else evas_key_modifier_off(e, "Shift");
322 if (mask & MOD_CTRL) evas_key_modifier_on (e, "Control");
323 else evas_key_modifier_off(e, "Control");
324 if (mask & MOD_ALT) evas_key_modifier_on (e, "Alt");
325 else evas_key_modifier_off(e, "Alt");
326 if (mask & MOD_META) evas_key_modifier_on (e, "Meta");
327 else evas_key_modifier_off(e, "Meta");
328 if (mask & MOD_HYPER) evas_key_modifier_on (e, "Hyper");
329 else evas_key_modifier_off(e, "Hyper");
330 if (mask & MOD_SUPER) evas_key_modifier_on (e, "Super");
331 else evas_key_modifier_off(e, "Super");
332 if (mask & MOD_SCROLL) evas_key_lock_on (e, "Scroll_Lock");
333 else evas_key_lock_off(e, "Scroll_Lock");
334 if (mask & MOD_NUM) evas_key_lock_on (e, "Num_Lock");
335 else evas_key_lock_off(e, "Num_Lock");
336 if (mask & MOD_CAPS) evas_key_lock_on (e, "Caps_Lock");
337 else evas_key_lock_off(e, "Caps_Lock");
338 }
339
340 static void
_ecore_evas_extn_cb_mouse_in(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info EINA_UNUSED)341 _ecore_evas_extn_cb_mouse_in(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
342 {
343 Ecore_Evas *ee = data;
344 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
345 Evas_Event_Mouse_In *ev = event_info;
346 Extn *extn;
347
348 extn = bdata->data;
349 if (!extn) return;
350 if (extn->ipc.server)
351 {
352 Ipc_Data_Ev_Mouse_In ipc;
353 memset(&ipc, 0, sizeof(ipc));
354
355 ipc.timestamp = ev->timestamp;
356 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
357 ipc.event_flags = ev->event_flags;
358 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MOUSE_IN, 0, 0, 0, &ipc, sizeof(ipc));
359 }
360 }
361
362 static void
_ecore_evas_extn_cb_mouse_out(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info EINA_UNUSED)363 _ecore_evas_extn_cb_mouse_out(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
364 {
365 Ecore_Evas *ee = data;
366 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
367 Evas_Event_Mouse_Out *ev = event_info;
368 Extn *extn;
369
370 extn = bdata->data;
371 if (!extn) return;
372 if (extn->ipc.server)
373 {
374 Ipc_Data_Ev_Mouse_Out ipc;
375 memset(&ipc, 0, sizeof(ipc));
376
377 ipc.timestamp = ev->timestamp;
378 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
379 ipc.event_flags = ev->event_flags;
380 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MOUSE_OUT, 0, 0, 0, &ipc, sizeof(ipc));
381 }
382 }
383
384 static void
_ecore_evas_extn_cb_mouse_down(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)385 _ecore_evas_extn_cb_mouse_down(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
386 {
387 Ecore_Evas *ee = data;
388 Evas_Event_Mouse_Down *ev = event_info;
389 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
390 Extn *extn;
391
392 extn = bdata->data;
393 if (!extn) return;
394 if (extn->ipc.server)
395 {
396 /* We have send mouse move event before mouse down event */
397 {
398 Ipc_Data_Ev_Mouse_Move ipc_move;
399 memset(&ipc_move, 0, sizeof(ipc_move));
400 Evas_Coord x, y;
401
402 x = ev->canvas.x;
403 y = ev->canvas.y;
404 _ecore_evas_extn_coord_translate(ee, &x, &y);
405 ipc_move.x = x;
406 ipc_move.y = y;
407 ipc_move.timestamp = ev->timestamp;
408 ipc_move.mask = _ecore_evas_modifiers_locks_mask_get(e);
409 ipc_move.event_flags = ev->event_flags;
410 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MOUSE_MOVE, 0, 0, 0, &ipc_move, sizeof(ipc_move));
411 }
412 {
413 Ipc_Data_Ev_Mouse_Down ipc;
414 memset(&ipc, 0, sizeof(ipc));
415 ipc.b = ev->button;
416 ipc.flags = ev->flags;
417 ipc.timestamp = ev->timestamp;
418 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
419 ipc.event_flags = ev->event_flags;
420 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MOUSE_DOWN, 0, 0, 0, &ipc, sizeof(ipc));
421 }
422 }
423 }
424
425 static void
_ecore_evas_extn_cb_mouse_up(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)426 _ecore_evas_extn_cb_mouse_up(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
427 {
428 Ecore_Evas *ee = data;
429 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
430 Evas_Event_Mouse_Up *ev = event_info;
431 Extn *extn;
432
433 extn = bdata->data;
434 if (!extn) return;
435 if (extn->ipc.server)
436 {
437 Ipc_Data_Ev_Mouse_Up ipc;
438 memset(&ipc, 0, sizeof(ipc));
439
440 ipc.b = ev->button;
441 ipc.flags = ev->flags;
442 ipc.timestamp = ev->timestamp;
443 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
444 ipc.event_flags = ev->event_flags;
445 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MOUSE_UP, 0, 0, 0, &ipc, sizeof(ipc));
446 }
447 }
448
449 static void
_ecore_evas_extn_cb_mouse_move(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)450 _ecore_evas_extn_cb_mouse_move(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
451 {
452 Ecore_Evas *ee = data;
453 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
454 Evas_Event_Mouse_Move *ev = event_info;
455 Extn *extn;
456
457 extn = bdata->data;
458 if (!extn) return;
459 if (extn->ipc.server)
460 {
461 Ipc_Data_Ev_Mouse_Move ipc;
462 memset(&ipc, 0, sizeof(ipc));
463 Evas_Coord x, y;
464
465 x = ev->cur.canvas.x;
466 y = ev->cur.canvas.y;
467 _ecore_evas_extn_coord_translate(ee, &x, &y);
468 ipc.x = x;
469 ipc.y = y;
470 ipc.timestamp = ev->timestamp;
471 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
472 ipc.event_flags = ev->event_flags;
473 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MOUSE_MOVE, 0, 0, 0, &ipc, sizeof(ipc));
474 }
475 }
476
477 static void
_ecore_evas_extn_cb_mouse_wheel(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)478 _ecore_evas_extn_cb_mouse_wheel(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
479 {
480 Ecore_Evas *ee = data;
481 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
482 Evas_Event_Mouse_Wheel *ev = event_info;
483 Extn *extn;
484
485 extn = bdata->data;
486 if (!extn) return;
487 if (extn->ipc.server)
488 {
489 Ipc_Data_Ev_Mouse_Wheel ipc;
490 memset(&ipc, 0, sizeof(ipc));
491
492 ipc.direction = ev->direction;
493 ipc.z = ev->z;
494 ipc.timestamp = ev->timestamp;
495 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
496 ipc.event_flags = ev->event_flags;
497 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MOUSE_WHEEL, 0, 0, 0, &ipc, sizeof(ipc));
498 }
499 }
500
501 static void
_ecore_evas_extn_cb_multi_down(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)502 _ecore_evas_extn_cb_multi_down(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
503 {
504 Ecore_Evas *ee = data;
505 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
506 Evas_Event_Multi_Down *ev = event_info;
507 Extn *extn;
508
509 extn = bdata->data;
510 if (!extn) return;
511 if (extn->ipc.server)
512 {
513 Ipc_Data_Ev_Multi_Down ipc;
514 memset(&ipc, 0, sizeof(ipc));
515 Evas_Coord x, y;
516
517 ipc.d = ev->device;
518 x = ev->canvas.x;
519 y = ev->canvas.y;
520 _ecore_evas_extn_coord_translate(ee, &x, &y);
521 ipc.x = x;
522 ipc.y = y;
523 ipc.rad = ev->radius;
524 ipc.radx = ev->radius_x;
525 ipc.rady = ev->radius_y;
526 ipc.pres = ev->pressure;
527 ipc.ang = ev->angle;
528 ipc.fx = ev->canvas.xsub;
529 ipc.fy = ev->canvas.ysub;
530 ipc.flags = ev->flags;
531 ipc.timestamp = ev->timestamp;
532 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
533 ipc.event_flags = ev->event_flags;
534 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MULTI_DOWN, 0, 0, 0, &ipc, sizeof(ipc));
535 }
536 }
537
538
539 static void
_ecore_evas_extn_cb_multi_up(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)540 _ecore_evas_extn_cb_multi_up(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
541 {
542 Ecore_Evas *ee = data;
543 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
544 Evas_Event_Multi_Up *ev = event_info;
545 Extn *extn;
546
547 extn = bdata->data;
548 if (!extn) return;
549 if (extn->ipc.server)
550 {
551 Ipc_Data_Ev_Multi_Up ipc;
552 memset(&ipc, 0, sizeof(ipc));
553 Evas_Coord x, y;
554
555 ipc.d = ev->device;
556 x = ev->canvas.x;
557 y = ev->canvas.y;
558 _ecore_evas_extn_coord_translate(ee, &x, &y);
559 ipc.x = x;
560 ipc.y = y;
561 ipc.rad = ev->radius;
562 ipc.radx = ev->radius_x;
563 ipc.rady = ev->radius_y;
564 ipc.pres = ev->pressure;
565 ipc.ang = ev->angle;
566 ipc.fx = ev->canvas.xsub;
567 ipc.fy = ev->canvas.ysub;
568 ipc.flags = ev->flags;
569 ipc.timestamp = ev->timestamp;
570 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
571 ipc.event_flags = ev->event_flags;
572 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MULTI_UP, 0, 0, 0, &ipc, sizeof(ipc));
573 }
574 }
575
576 static void
_ecore_evas_extn_cb_multi_move(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)577 _ecore_evas_extn_cb_multi_move(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
578 {
579 Ecore_Evas *ee = data;
580 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
581 Evas_Event_Multi_Move *ev = event_info;
582 Extn *extn;
583
584 extn = bdata->data;
585 if (!extn) return;
586 if (extn->ipc.server)
587 {
588 Ipc_Data_Ev_Multi_Move ipc;
589 memset(&ipc, 0, sizeof(ipc));
590 Evas_Coord x, y;
591
592 ipc.d = ev->device;
593 x = ev->cur.canvas.x;
594 y = ev->cur.canvas.y;
595 _ecore_evas_extn_coord_translate(ee, &x, &y);
596 ipc.x = x;
597 ipc.y = y;
598 ipc.rad = ev->radius;
599 ipc.radx = ev->radius_x;
600 ipc.rady = ev->radius_y;
601 ipc.pres = ev->pressure;
602 ipc.ang = ev->angle;
603 ipc.fx = ev->cur.canvas.xsub;
604 ipc.fy = ev->cur.canvas.ysub;
605 ipc.timestamp = ev->timestamp;
606 ipc.mask = _ecore_evas_modifiers_locks_mask_get(e);
607 ipc.event_flags = ev->event_flags;
608 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_MULTI_MOVE, 0, 0, 0, &ipc, sizeof(ipc));
609 }
610 }
611
612 static void
_ecore_evas_extn_cb_key_down(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)613 _ecore_evas_extn_cb_key_down(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
614 {
615 Ecore_Evas *ee = data;
616 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
617 Evas_Event_Key_Down *ev = event_info;
618 Extn *extn;
619
620 extn = bdata->data;
621 if (!extn) return;
622 if (extn->ipc.server)
623 {
624 Ipc_Data_Ev_Key_Down *ipc;
625 char *st, *p;
626 int len = 0;
627
628 len = sizeof(Ipc_Data_Ev_Key_Down);
629 if (ev->key) len += strlen(ev->key) + 1;
630 if (ev->keyname) len += strlen(ev->keyname) + 1;
631 if (ev->string) len += strlen(ev->string) + 1;
632 if (ev->compose) len += strlen(ev->compose) + 1;
633 len += 1;
634 st = alloca(len);
635 ipc = (Ipc_Data_Ev_Key_Down *)st;
636 memset(st, 0, len);
637 p = st + sizeof(Ipc_Data_Ev_Key_Down);
638 if (ev->key)
639 {
640 strcpy(p, ev->key);
641 ipc->key = p - (long)st;
642 p += strlen(p) + 1;
643 }
644 if (ev->keyname)
645 {
646 strcpy(p, ev->keyname);
647 ipc->keyname = p - (long)st;
648 p += strlen(p) + 1;
649 }
650 if (ev->string)
651 {
652 strcpy(p, ev->string);
653 ipc->string = p - (long)st;
654 p += strlen(p) + 1;
655 }
656 if (ev->compose)
657 {
658 strcpy(p, ev->compose);
659 ipc->compose = p - (long)st;
660 p += strlen(p) + 1;
661 }
662 ipc->timestamp = ev->timestamp;
663 ipc->mask = _ecore_evas_modifiers_locks_mask_get(e);
664 ipc->event_flags = ev->event_flags;
665 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_KEY_DOWN, 0, 0, 0, ipc, len);
666 }
667 }
668
669 static void
_ecore_evas_extn_cb_key_up(void * data,Evas * e,Evas_Object * obj EINA_UNUSED,void * event_info)670 _ecore_evas_extn_cb_key_up(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
671 {
672 Ecore_Evas *ee = data;
673 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
674 Evas_Event_Key_Up *ev = event_info;
675 Extn *extn;
676
677 extn = bdata->data;
678 if (!extn) return;
679 if (extn->ipc.server)
680 {
681 Ipc_Data_Ev_Key_Up *ipc;
682 char *st, *p;
683 int len = 0;
684
685 len = sizeof(Ipc_Data_Ev_Key_Up);
686 if (ev->key) len += strlen(ev->key) + 1;
687 if (ev->keyname) len += strlen(ev->keyname) + 1;
688 if (ev->string) len += strlen(ev->string) + 1;
689 if (ev->compose) len += strlen(ev->compose) + 1;
690 len += 1;
691 st = alloca(len);
692 ipc = (Ipc_Data_Ev_Key_Up *)st;
693 memset(st, 0, len);
694 p = st + sizeof(Ipc_Data_Ev_Key_Down);
695 if (ev->key)
696 {
697 strcpy(p, ev->key);
698 ipc->key = p - (long)st;
699 p += strlen(p) + 1;
700 }
701 if (ev->keyname)
702 {
703 strcpy(p, ev->keyname);
704 ipc->keyname = p - (long)st;
705 p += strlen(p) + 1;
706 }
707 if (ev->string)
708 {
709 strcpy(p, ev->string);
710 ipc->string = p - (long)st;
711 p += strlen(p) + 1;
712 }
713 if (ev->compose)
714 {
715 strcpy(p, ev->compose);
716 ipc->compose = p - (long)st;
717 p += strlen(p) + 1;
718 }
719 ipc->timestamp = ev->timestamp;
720 ipc->mask = _ecore_evas_modifiers_locks_mask_get(e);
721 ipc->event_flags = ev->event_flags;
722 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_KEY_UP, 0, 0, 0, ipc, len);
723 }
724 }
725
726 static void
_ecore_evas_extn_cb_hold(void * data,Evas * e EINA_UNUSED,Evas_Object * obj EINA_UNUSED,void * event_info)727 _ecore_evas_extn_cb_hold(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
728 {
729 Ecore_Evas *ee = data;
730 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
731 Evas_Event_Hold *ev = event_info;
732 Extn *extn;
733
734 extn = bdata->data;
735 if (!extn) return;
736 if (extn->ipc.server)
737 {
738 Ipc_Data_Ev_Hold ipc;
739 memset(&ipc, 0, sizeof(ipc));
740
741 ipc.hold = ev->hold;
742 ipc.timestamp = ev->timestamp;
743 ipc.event_flags = ev->event_flags;
744 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_EV_HOLD, 0, 0, 0, &ipc, sizeof(ipc));
745 }
746 }
747
748 static void
_ecore_evas_extn_cb_focus_in(void * data,Evas * e EINA_UNUSED,Evas_Object * obj EINA_UNUSED,void * event_info EINA_UNUSED)749 _ecore_evas_extn_cb_focus_in(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
750 {
751 Ecore_Evas *ee = data;
752 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
753 Extn *extn;
754 Evas_Device *dev;
755
756 dev = evas_default_device_get(ee->evas, EVAS_DEVICE_CLASS_SEAT);
757 if (ecore_evas_focus_device_get(ee, dev)) return;
758 ee->prop.focused_by = eina_list_append(ee->prop.focused_by, dev);
759 extn = bdata->data;
760 if (!extn) return;
761 if (!extn->ipc.server) return;
762 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_FOCUS, 0, 0, 0, NULL, 0);
763 }
764
765 static void
_ecore_evas_extn_cb_focus_out(void * data,Evas * e EINA_UNUSED,Evas_Object * obj EINA_UNUSED,void * event_info EINA_UNUSED)766 _ecore_evas_extn_cb_focus_out(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
767 {
768 Ecore_Evas *ee = data;
769 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
770 Extn *extn;
771
772 ee->prop.focused_by = eina_list_remove(ee->prop.focused_by,
773 evas_default_device_get(ee->evas, EVAS_DEVICE_CLASS_SEAT));
774 extn = bdata->data;
775 if (!extn) return;
776 if (!extn->ipc.server) return;
777 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_UNFOCUS, 0, 0, 0, NULL, 0);
778 }
779
780 static void
_ecore_evas_extn_cb_show(void * data,Evas * e EINA_UNUSED,Evas_Object * obj EINA_UNUSED,void * event_info EINA_UNUSED)781 _ecore_evas_extn_cb_show(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
782 {
783 Ecore_Evas *ee = data;
784 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
785 Extn *extn;
786
787 ee->visible = 1;
788 extn = bdata->data;
789 if (!extn) return;
790 if (!extn->ipc.server) return;
791 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_SHOW, 0, 0, 0, NULL, 0);
792 }
793
794 static void
_ecore_evas_extn_cb_hide(void * data,Evas * e EINA_UNUSED,Evas_Object * obj EINA_UNUSED,void * event_info EINA_UNUSED)795 _ecore_evas_extn_cb_hide(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
796 {
797 Ecore_Evas *ee = data;
798 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
799 Extn *extn;
800
801 ee->visible = 0;
802 extn = bdata->data;
803 if (!extn) return;
804 if (!extn->ipc.server) return;
805 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_HIDE, 0, 0, 0, NULL, 0);
806 }
807
808 static void
_ecore_evas_extn_plug_profile_set(Ecore_Evas * ee,const char * profile)809 _ecore_evas_extn_plug_profile_set(Ecore_Evas *ee, const char *profile)
810 {
811 Extn *extn;
812 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
813
814 _ecore_evas_window_profile_free(ee);
815 ee->prop.profile.name = NULL;
816
817 extn = bdata->data;
818 if (!extn) return;
819
820 if (profile)
821 {
822 ee->prop.profile.name = (char *)eina_stringshare_add(profile);
823 if (extn->ipc.server)
824 ecore_ipc_server_send(extn->ipc.server, MAJOR,
825 OP_PROFILE_CHANGE_REQUEST,
826 0, 0, 0, profile, strlen(profile) + 1);
827 }
828 }
829
830 static void
_ecore_evas_extn_plug_msg_parent_send(Ecore_Evas * ee,int msg_domain,int msg_id,void * data,int size)831 _ecore_evas_extn_plug_msg_parent_send(Ecore_Evas *ee, int msg_domain, int msg_id, void *data, int size)
832 {
833 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
834 Extn *extn;
835
836 extn = bdata->data;
837 if (!extn) return;
838 if (!extn->ipc.server) return;
839
840 //ref = msg_domain
841 //ref_to = msg_id
842 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_MSG, msg_domain, msg_id, 0, data, size);
843 }
844
845 static const Ecore_Evas_Engine_Func _ecore_extn_plug_engine_func =
846 {
847 _ecore_evas_extn_free,
848 NULL, // fn_callback_resize_set
849 NULL, // fn_callback_move_set
850 NULL, // fn_callback_show_set
851 NULL, // fn_callback_hide_set
852 NULL, // fn_callback_delete_request_set
853 NULL, // fn_callback_destroy_set
854 NULL, // fn_callback_focus_in_set
855 NULL, // fn_callback_focus_out_set
856 NULL, // fn_callback_mouse_in_set
857 NULL, // fn_callback_mouse_out_set
858 NULL, // fn_callback_sticky_set
859 NULL, // fn_callback_unsticky_set
860 NULL, // fn_callback_pre_render_set
861 NULL, // fn_callback_post_render_set
862 NULL, // fn_move
863 NULL, // fn_managed_move
864 _ecore_evas_resize,
865 _ecore_evas_move_resize,
866 NULL, // fn_rotation_set
867 NULL, // fn_shaped_set
868 NULL, // fn_show
869 NULL, // fn_hide
870 NULL, // fn_raise
871 NULL, // fn_lower
872 NULL, // fn_activate
873 NULL, // fn_title_set
874 NULL, // fn_name_class_set
875 NULL, // fn_size_min_set
876 NULL, // fn_size_max_set
877 NULL, // fn_size_base_set
878 NULL, // fn_size_step_set
879 NULL, // fn_object_cursor_set
880 NULL, // fn_object_cursor_unset
881 NULL, // fn_layer_set
882 NULL, // fn_focus_set
883 NULL, // fn_iconified_set
884 NULL, // fn_borderless_set
885 NULL, // fn_override_set
886 NULL, // fn_maximized_set
887 NULL, // fn_fullscreen_set
888 NULL, // fn_avoid_damage_set
889 NULL, // fn_withdrawn_set
890 NULL, // fn_sticky_set
891 NULL, // fn_ignore_events_set
892 NULL, // fn_alpha_set
893 NULL, // fn_transparent_set
894 NULL, // fn_profiles_set
895 _ecore_evas_extn_plug_profile_set,
896
897 NULL, // fn_window_group_set
898 NULL, // fn_aspect_set
899 NULL, // fn_urgent_set
900 NULL, // fn_modal_set
901 NULL, // fn_demands_attention_set
902 NULL, // fn_focus_skip_set
903
904 NULL, // fn_render
905 NULL, // fn_screen_geometry_get
906 NULL, // fn_screen_dpi_get
907 _ecore_evas_extn_plug_msg_parent_send,
908 NULL, // fn_msg_send
909
910 /* 1.8 abstractions */
911 NULL, // pointer_xy_get
912 NULL, // pointer_warp
913
914 NULL, // wm_rot_preferred_rotation_set
915 NULL, // wm_rot_available_rotations_set
916 NULL, // wm_rot_manual_rotation_done_set
917 NULL, // wm_rot_manual_rotation_done
918
919 NULL, // aux_hints_set
920
921 NULL, // fn_animator_register
922 NULL, // fn_animator_unregister
923
924 NULL, // fn_evas_changed
925
926 NULL, // fn_focus_device_set
927 NULL, // fn_callback_focus_device_in_set
928 NULL, // fn_callback_focus_device_out_set
929
930 NULL, // fn_callback_device_mouse_in_set
931 NULL, // fn_callback_device_mouse_out_set
932 NULL, // fn_pointer_device_xy_get
933
934 NULL, // fn_prepare
935
936 NULL // fn_last_tick_get
937 };
938
939 static Eina_Bool
_ipc_server_add(void * data,int type EINA_UNUSED,void * event)940 _ipc_server_add(void *data, int type EINA_UNUSED, void *event)
941 {
942 Ecore_Ipc_Event_Server_Add *e = event;
943 Ecore_Evas *ee = data;
944 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
945 Extn *extn;
946
947 if (ee != ecore_ipc_server_data_get(e->server))
948 return ECORE_CALLBACK_PASS_ON;
949 if (!eina_list_data_find(extn_ee_list, ee))
950 return ECORE_CALLBACK_PASS_ON;
951 extn = bdata->data;
952 if (!extn) return ECORE_CALLBACK_PASS_ON;
953 /* If a server relaunches while a client is running, the server cannot get the OP_SHOW.
954 In this case, the client should send the OP_SHOW, when the server is added. */
955 if (ee->visible && extn->ipc.server)
956 ecore_ipc_server_send(extn->ipc.server, MAJOR, OP_SHOW, 0, 0, 0, NULL, 0);
957 //FIXME: find a way to let app know server there
958 return ECORE_CALLBACK_PASS_ON;
959 }
960
961 static Eina_Bool
_ipc_server_del(void * data,int type EINA_UNUSED,void * event)962 _ipc_server_del(void *data, int type EINA_UNUSED, void *event)
963 {
964 Ecore_Ipc_Event_Server_Del *e = event;
965 Ecore_Evas *ee = data;
966 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
967 Extn *extn;
968 int i;
969
970 extn = bdata->data;
971 if (!extn) return ECORE_CALLBACK_PASS_ON;
972 if (extn->ipc.server != e->server) return ECORE_CALLBACK_PASS_ON;
973 evas_object_image_data_set(bdata->image, NULL);
974 evas_object_image_pixels_dirty_set(bdata->image, EINA_TRUE);
975 bdata->pixels = NULL;
976 extn->ipc.server = NULL;
977
978 for (i = 0; i < NBUF; i++)
979 {
980 if (extn->b[i].buf) _extnbuf_free(extn->b[i].buf);
981 if (extn->b[i].obuf) _extnbuf_free(extn->b[i].obuf);
982 if (extn->b[i].base) eina_stringshare_del(extn->b[i].base);
983 if (extn->b[i].lock) eina_stringshare_del(extn->b[i].lock);
984 extn->b[i].buf = NULL;
985 extn->b[i].obuf = NULL;
986 extn->b[i].base = NULL;
987 extn->b[i].lock = NULL;
988 }
989 if (ee->func.fn_delete_request) ee->func.fn_delete_request(ee);
990 return ECORE_CALLBACK_PASS_ON;
991 }
992
993 static Eina_Bool
_ipc_server_data(void * data,int type EINA_UNUSED,void * event)994 _ipc_server_data(void *data, int type EINA_UNUSED, void *event)
995 {
996 Ecore_Ipc_Event_Server_Data *e = event;
997 Ecore_Evas *ee = data;
998 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
999 Extn *extn;
1000
1001 if (ee != ecore_ipc_server_data_get(e->server))
1002 return ECORE_CALLBACK_PASS_ON;
1003 if (!eina_list_data_find(extn_ee_list, ee))
1004 return ECORE_CALLBACK_PASS_ON;
1005 extn = bdata->data;
1006 if (!extn) return ECORE_CALLBACK_PASS_ON;
1007 if (e->major != MAJOR)
1008 return ECORE_CALLBACK_PASS_ON;
1009 if (ee != ecore_ipc_server_data_get(extn->ipc.server))
1010 return ECORE_CALLBACK_PASS_ON;
1011 switch (e->minor)
1012 {
1013 case OP_UPDATE:
1014 // add rect to update list
1015 if (e->size >= (int)sizeof(Ipc_Data_Update))
1016 {
1017 Ipc_Data_Update *ipc = malloc(sizeof(Ipc_Data_Update));
1018 if (ipc)
1019 {
1020 memcpy(ipc, e->data, sizeof(Ipc_Data_Update));
1021 extn->file.updates = eina_list_append(extn->file.updates,
1022 ipc);
1023 }
1024 }
1025 break;
1026 case OP_UPDATE_DONE:
1027 // e->response == display buffer #
1028 // updates finished being sent - done now. frame ready
1029 {
1030 Ipc_Data_Update *ipc;
1031 int n = e->response;
1032
1033 /* b->lockfd is not enough to ensure the size is same
1034 * between what server knows, and client knows.
1035 * So should check file lock also. */
1036 if ((n >= 0) && (n < NBUF))
1037 {
1038 if (extn->b[n].buf && (!_extnbuf_lock_file_get(extn->b[n].buf)))
1039 {
1040 EINA_LIST_FREE(extn->file.updates, ipc)
1041 {
1042 free(ipc);
1043 }
1044 break;
1045 }
1046 }
1047
1048 EINA_LIST_FREE(extn->file.updates, ipc)
1049 {
1050 if (bdata->image)
1051 evas_object_image_data_update_add(bdata->image,
1052 ipc->x, ipc->y,
1053 ipc->w, ipc->h);
1054 free(ipc);
1055 }
1056 if ((n >= 0) && (n < NBUF))
1057 {
1058 void *data2;
1059 int w = 0, h = 0, pn;
1060
1061 pn = extn->cur_b;
1062 extn->cur_b = n;
1063
1064 if (extn->b[pn].buf) _extnbuf_unlock(extn->b[pn].buf);
1065
1066 evas_object_image_colorspace_set(bdata->image, EVAS_COLORSPACE_ARGB8888);
1067 if (extn->b[n].buf)
1068 {
1069 data2 = _extnbuf_data_get(extn->b[n].buf, &w, &h, NULL);
1070 bdata->pixels = data2;
1071 evas_object_image_alpha_set(bdata->image,
1072 extn->b[n].alpha);
1073 evas_object_image_size_set(bdata->image, w, h);
1074 evas_object_image_data_set(bdata->image, data2);
1075 }
1076 else
1077 {
1078 bdata->pixels = NULL;
1079 evas_object_image_alpha_set(bdata->image, EINA_TRUE);
1080 evas_object_image_size_set(bdata->image, 1, 1);
1081 evas_object_image_data_set(bdata->image, &blank);
1082 }
1083 }
1084 }
1085 break;
1086 case OP_SHM_REF0:
1087 // e->ref == shm id
1088 // e->ref_to == shm num
1089 // e->response == buffer num
1090 // e->data = shm ref string + nul byte
1091 if ((e->data) && (e->size > 0) &&
1092 (((unsigned char *)e->data)[e->size - 1] == 0))
1093 {
1094 int n = e->response;
1095
1096 if ((n >= 0) && (n < NBUF))
1097 {
1098 extn->b[n].id = e->ref;
1099 extn->b[n].num = e->ref_to;
1100 if (extn->b[n].base) eina_stringshare_del(extn->b[n].base);
1101 extn->b[n].base = eina_stringshare_add(e->data);
1102 }
1103 }
1104 break;
1105 case OP_SHM_REF1:
1106 // e->ref == w
1107 // e->ref_to == h
1108 // e->response == buffer num
1109 // e->data = lockfile + nul byte
1110 if ((e->data) && (e->size > 0) &&
1111 (((unsigned char *)e->data)[e->size - 1] == 0))
1112 {
1113 int n = e->response;
1114
1115 if ((n >= 0) && (n < NBUF))
1116 {
1117 extn->b[n].w = e->ref;
1118 extn->b[n].h = e->ref_to;
1119 if (extn->b[n].lock) eina_stringshare_del(extn->b[n].lock);
1120 extn->b[n].lock = eina_stringshare_add(e->data);
1121 }
1122 }
1123 break;
1124 case OP_SHM_REF2:
1125 // e->ref == alpha
1126 // e->ref_to == sys
1127 // e->response == buffer num
1128 {
1129 int n = e->response;
1130
1131 if ((n >= 0) && (n < NBUF))
1132 {
1133 extn->b[n].alpha = e->ref;
1134 extn->b[n].sys = e->ref_to;
1135 if (extn->b[n].buf)
1136 {
1137 if (_extnbuf_lock_get(extn->b[n].buf))
1138 {
1139 if (extn->b[n].obuf) ERR("obuf is non-null");
1140 extn->b[n].obuf = extn->b[n].buf;
1141 }
1142 else
1143 _extnbuf_free(extn->b[n].buf);
1144 }
1145 extn->b[n].buf = _extnbuf_new(extn->b[n].base,
1146 extn->b[n].id,
1147 extn->b[n].sys,
1148 extn->b[n].num,
1149 extn->b[n].w,
1150 extn->b[n].h,
1151 EINA_FALSE);
1152 if ((extn->b[n].buf) && (extn->b[n].lock))
1153 _extnbuf_lock_file_set(extn->b[n].buf,
1154 extn->b[n].lock);
1155 }
1156 }
1157 break;
1158 case OP_RESIZE:
1159 if ((e->data) && (e->size >= (int)sizeof(Ipc_Data_Resize)))
1160 {
1161 Ipc_Data_Resize *ipc = e->data;
1162 _ecore_evas_resize(ee, ipc->w, ipc->h);
1163 }
1164 break;
1165 case OP_PROFILE_CHANGE_DONE:
1166 /* profile change finished being sent - done now. */
1167 /* do something here */
1168 break;
1169 case OP_MSG_PARENT:
1170 if ((e->data) && (e->size > 0))
1171 {
1172 //ref = msg_domain
1173 //ref_to = msg_id
1174 if (ee->func.fn_msg_handle)
1175 {
1176 INF("Message handle: ref=%d to=%d size=%d", e->ref, e->ref_to, e->size);
1177 ee->func.fn_msg_handle(ee, e->ref, e->ref_to, e->data, e->size);
1178 }
1179 }
1180 break;
1181 default:
1182 break;
1183 }
1184 return ECORE_CALLBACK_PASS_ON;
1185 }
1186
1187 EAPI Evas_Object *
ecore_evas_extn_plug_new_internal(Ecore_Evas * ee_target)1188 ecore_evas_extn_plug_new_internal(Ecore_Evas *ee_target)
1189 {
1190 Evas_Object *o;
1191 Ecore_Evas *ee;
1192 Ecore_Evas_Engine_Buffer_Data *bdata;
1193 Ecore_Evas_Interface_Extn *iface;
1194 int w = 1, h = 1;
1195
1196 if (!ee_target) return NULL;
1197
1198 ee = calloc(1, sizeof(Ecore_Evas));
1199 if (!ee) return NULL;
1200 bdata = calloc(1, sizeof(Ecore_Evas_Engine_Buffer_Data));
1201 if (!bdata)
1202 {
1203 free(ee);
1204 return NULL;
1205 }
1206 ee->engine.data = bdata;
1207 o = evas_object_image_filled_add(ee_target->evas);
1208 /* this make problem in gl engine, so I'll block this until solve problem
1209 evas_object_image_content_hint_set(o, EVAS_IMAGE_CONTENT_HINT_DYNAMIC);*/
1210 evas_object_image_colorspace_set(o, EVAS_COLORSPACE_ARGB8888);
1211 evas_object_image_alpha_set(o, 1);
1212 evas_object_image_size_set(o, 1, 1);
1213 evas_object_image_data_set(o, &blank);
1214
1215 ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
1216
1217 ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_extn_plug_engine_func;
1218
1219 ee->driver = "extn_plug";
1220
1221 iface = _ecore_evas_extn_interface_new();
1222 ee->engine.ifaces = eina_list_append(ee->engine.ifaces, iface);
1223
1224 ee->rotation = 0;
1225 ee->visible = 0;
1226 ee->w = w;
1227 ee->h = h;
1228 ee->req.w = ee->w;
1229 ee->req.h = ee->h;
1230 ee->profile_supported = 1;
1231 ee->can_async_render = 0;
1232
1233 ee->prop.max.w = 0;
1234 ee->prop.max.h = 0;
1235 ee->prop.layer = 0;
1236 ee->prop.borderless = EINA_TRUE;
1237 ee->prop.override = EINA_TRUE;
1238 ee->prop.maximized = EINA_FALSE;
1239 ee->prop.fullscreen = EINA_FALSE;
1240 ee->prop.withdrawn = EINA_TRUE;
1241 ee->prop.sticky = EINA_FALSE;
1242
1243 bdata->image = o;
1244 evas_object_data_set(bdata->image, "Ecore_Evas", ee);
1245 evas_object_data_set(bdata->image, "Ecore_Evas_Parent", ee_target);
1246 evas_object_event_callback_add(bdata->image,
1247 EVAS_CALLBACK_MOUSE_IN,
1248 _ecore_evas_extn_cb_mouse_in, ee);
1249 evas_object_event_callback_add(bdata->image,
1250 EVAS_CALLBACK_MOUSE_OUT,
1251 _ecore_evas_extn_cb_mouse_out, ee);
1252 evas_object_event_callback_add(bdata->image,
1253 EVAS_CALLBACK_MOUSE_DOWN,
1254 _ecore_evas_extn_cb_mouse_down, ee);
1255 evas_object_event_callback_add(bdata->image,
1256 EVAS_CALLBACK_MOUSE_UP,
1257 _ecore_evas_extn_cb_mouse_up, ee);
1258 evas_object_event_callback_add(bdata->image,
1259 EVAS_CALLBACK_MOUSE_MOVE,
1260 _ecore_evas_extn_cb_mouse_move, ee);
1261 evas_object_event_callback_add(bdata->image,
1262 EVAS_CALLBACK_MOUSE_WHEEL,
1263 _ecore_evas_extn_cb_mouse_wheel, ee);
1264 evas_object_event_callback_add(bdata->image,
1265 EVAS_CALLBACK_MULTI_DOWN,
1266 _ecore_evas_extn_cb_multi_down, ee);
1267 evas_object_event_callback_add(bdata->image,
1268 EVAS_CALLBACK_MULTI_UP,
1269 _ecore_evas_extn_cb_multi_up, ee);
1270 evas_object_event_callback_add(bdata->image,
1271 EVAS_CALLBACK_MULTI_MOVE,
1272 _ecore_evas_extn_cb_multi_move, ee);
1273 evas_object_event_callback_add(bdata->image,
1274 EVAS_CALLBACK_KEY_DOWN,
1275 _ecore_evas_extn_cb_key_down, ee);
1276 evas_object_event_callback_add(bdata->image,
1277 EVAS_CALLBACK_KEY_UP,
1278 _ecore_evas_extn_cb_key_up, ee);
1279 evas_object_event_callback_add(bdata->image,
1280 EVAS_CALLBACK_HOLD,
1281 _ecore_evas_extn_cb_hold, ee);
1282 evas_object_event_callback_add(bdata->image,
1283 EVAS_CALLBACK_FOCUS_IN,
1284 _ecore_evas_extn_cb_focus_in, ee);
1285 evas_object_event_callback_add(bdata->image,
1286 EVAS_CALLBACK_FOCUS_OUT,
1287 _ecore_evas_extn_cb_focus_out, ee);
1288 evas_object_event_callback_add(bdata->image,
1289 EVAS_CALLBACK_SHOW,
1290 _ecore_evas_extn_cb_show, ee);
1291 evas_object_event_callback_add(bdata->image,
1292 EVAS_CALLBACK_HIDE,
1293 _ecore_evas_extn_cb_hide, ee);
1294
1295 evas_object_event_callback_add(bdata->image,
1296 EVAS_CALLBACK_DEL,
1297 _ecore_evas_extn_plug_image_obj_del, ee);
1298
1299
1300 extn_ee_list = eina_list_append(extn_ee_list, ee);
1301 _ecore_evas_subregister(ee_target, ee);
1302
1303 evas_event_callback_add(ee_target->evas, EVAS_CALLBACK_RENDER_PRE,
1304 _ecore_evas_extn_plug_render_pre, ee);
1305 evas_event_callback_add(ee_target->evas, EVAS_CALLBACK_RENDER_POST,
1306 _ecore_evas_extn_plug_render_post, ee);
1307
1308 return o;
1309 }
1310
1311 static Eina_Bool
_ecore_evas_extn_plug_connect(Ecore_Evas * ee,const char * svcname,int svcnum,Eina_Bool svcsys)1312 _ecore_evas_extn_plug_connect(Ecore_Evas *ee, const char *svcname, int svcnum, Eina_Bool svcsys)
1313 {
1314 Extn *extn;
1315 Ecore_Evas_Engine_Buffer_Data *bdata;
1316
1317 if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS)) return EINA_FALSE;
1318
1319 bdata = ee->engine.data;
1320 if (!svcname)
1321 {
1322 bdata->data = NULL;
1323 return EINA_FALSE;
1324 }
1325
1326 extn = calloc(1, sizeof(Extn));
1327 if (!extn) return EINA_FALSE;
1328
1329
1330
1331 Ecore_Ipc_Type ipctype = ECORE_IPC_LOCAL_USER;
1332
1333 ecore_ipc_init();
1334 extn->svc.name = eina_stringshare_add(svcname);
1335 extn->svc.num = svcnum;
1336 extn->svc.sys = svcsys;
1337
1338 if (extn->svc.sys) ipctype = ECORE_IPC_LOCAL_SYSTEM;
1339 extn->ipc.server = ecore_ipc_server_connect(ipctype, (char *)extn->svc.name,
1340 extn->svc.num, ee);
1341 if (!extn->ipc.server)
1342 {
1343 bdata->data = NULL;
1344 eina_stringshare_del(extn->svc.name);
1345 free(extn);
1346 ecore_ipc_shutdown();
1347 return EINA_FALSE;
1348 }
1349 bdata->data = extn;
1350 extn->ipc.handlers = eina_list_append
1351 (extn->ipc.handlers,
1352 ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_ADD,
1353 _ipc_server_add, ee));
1354 extn->ipc.handlers = eina_list_append
1355 (extn->ipc.handlers,
1356 ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DEL,
1357 _ipc_server_del, ee));
1358 extn->ipc.handlers = eina_list_append
1359 (extn->ipc.handlers,
1360 ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DATA,
1361 _ipc_server_data, ee));
1362 return EINA_TRUE;
1363 }
1364
1365 static void
_ecore_evas_socket_resize(Ecore_Evas * ee,int w,int h)1366 _ecore_evas_socket_resize(Ecore_Evas *ee, int w, int h)
1367 {
1368 Extn *extn;
1369 Evas_Engine_Info_Buffer *einfo;
1370 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1371 int stride = 0;
1372
1373 if (w < 1) w = 1;
1374 if (h < 1) h = 1;
1375 ee->req.w = w;
1376 ee->req.h = h;
1377 if ((w == ee->w) && (h == ee->h)) return;
1378 ee->w = w;
1379 ee->h = h;
1380 evas_output_size_set(ee->evas, ee->w, ee->h);
1381 evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
1382 evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
1383 extn = bdata->data;
1384 if (extn)
1385 {
1386 int i, last_try = 0;
1387
1388 for (i = 0; i < NBUF; i++)
1389 {
1390 if (extn->b[i].buf) _extnbuf_free(extn->b[i].buf);
1391 if (extn->b[i].obuf) _extnbuf_free(extn->b[i].obuf);
1392 if (extn->b[i].base) eina_stringshare_del(extn->b[i].base);
1393 if (extn->b[i].lock) eina_stringshare_del(extn->b[i].lock);
1394 extn->b[i].buf = NULL;
1395 extn->b[i].obuf = NULL;
1396 extn->b[i].base = NULL;
1397 extn->b[i].lock = NULL;
1398 }
1399 bdata->pixels = NULL;
1400 for (i = 0; i < NBUF; i++)
1401 {
1402 do
1403 {
1404 extn->b[i].buf = _extnbuf_new(extn->svc.name, extn->svc.num,
1405 extn->svc.sys, last_try,
1406 ee->w, ee->h, EINA_TRUE);
1407 if (extn->b[i].buf) extn->b[i].num = last_try;
1408 last_try++;
1409 if (last_try > 1024) break;
1410 }
1411 while (!extn->b[i].buf);
1412
1413 }
1414
1415 if (extn->b[extn->cur_b].buf)
1416 bdata->pixels = _extnbuf_data_get(extn->b[extn->cur_b].buf,
1417 NULL, NULL, &stride);
1418 einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
1419 if (einfo)
1420 {
1421 if (ee->alpha)
1422 einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
1423 else
1424 einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_RGB32;
1425 einfo->info.dest_buffer = bdata->pixels;
1426 einfo->info.dest_buffer_row_bytes = stride;
1427 einfo->info.use_color_key = 0;
1428 einfo->info.alpha_threshold = 0;
1429 einfo->info.func.new_update_region = NULL;
1430 einfo->info.func.free_update_region = NULL;
1431 einfo->info.func.switch_buffer = _ecore_evas_socket_switch;
1432 einfo->info.switch_data = ee;
1433 if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
1434 {
1435 ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
1436 }
1437 }
1438
1439 if (extn->ipc.clients && extn->b[extn->cur_b].buf)
1440 {
1441 Ipc_Data_Resize ipc;
1442 Eina_List *l;
1443 Ecore_Ipc_Client *client;
1444
1445 EINA_LIST_FOREACH(extn->ipc.clients, l, client)
1446 {
1447 for (i = 0; i < NBUF; i++)
1448 {
1449 const char *lock;
1450
1451 ecore_ipc_client_send(client, MAJOR, OP_SHM_REF0,
1452 extn->svc.num, extn->b[i].num, i,
1453 extn->svc.name,
1454 strlen(extn->svc.name) + 1);
1455 lock = _extnbuf_lock_file_get(extn->b[i].buf);
1456 ecore_ipc_client_send(client, MAJOR, OP_SHM_REF1,
1457 ee->w, ee->h, i,
1458 lock, strlen(lock) + 1);
1459 ecore_ipc_client_send(client, MAJOR, OP_SHM_REF2,
1460 ee->alpha, extn->svc.sys, i,
1461 NULL, 0);
1462 ipc.w = ee->w;
1463 ipc.h = ee->h;
1464 ecore_ipc_client_send(client, MAJOR, OP_RESIZE,
1465 0, 0, 0, &ipc, sizeof(ipc));
1466 }
1467 }
1468 }
1469 }
1470 if (ee->func.fn_resize) ee->func.fn_resize(ee);
1471 }
1472
1473 static void
_ecore_evas_socket_move_resize(Ecore_Evas * ee,int x EINA_UNUSED,int y EINA_UNUSED,int w,int h)1474 _ecore_evas_socket_move_resize(Ecore_Evas *ee, int x EINA_UNUSED, int y EINA_UNUSED, int w, int h)
1475 {
1476 _ecore_evas_socket_resize(ee, w, h);
1477 }
1478
1479 static void
_ecore_evas_extn_socket_window_profile_change_done_send(Ecore_Evas * ee)1480 _ecore_evas_extn_socket_window_profile_change_done_send(Ecore_Evas *ee)
1481 {
1482 Extn *extn;
1483 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1484 Ecore_Ipc_Client *client;
1485 Eina_List *l = NULL;
1486 char *s;
1487 int len = 0;
1488
1489 extn = bdata->data;
1490 if (!extn) return;
1491 s = ee->prop.profile.name;
1492 if (s) len = strlen(s);
1493 EINA_LIST_FOREACH(extn->ipc.clients, l, client)
1494 {
1495 ecore_ipc_client_send(client, MAJOR,
1496 OP_PROFILE_CHANGE_DONE,
1497 0, 0, 0, s, len);
1498 }
1499 }
1500
1501 static void *
_ecore_evas_socket_switch(void * data,void * dest_buf EINA_UNUSED)1502 _ecore_evas_socket_switch(void *data, void *dest_buf EINA_UNUSED)
1503 {
1504 Ecore_Evas *ee = data;
1505 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1506 Extn *extn = bdata->data;
1507
1508 extn->prev_b = extn->cur_b;
1509 extn->cur_b++;
1510 if (extn->cur_b >= NBUF) extn->cur_b = 0;
1511 bdata->pixels = _extnbuf_data_get(extn->b[extn->cur_b].buf,
1512 NULL, NULL, NULL);
1513 return bdata->pixels;
1514 }
1515
1516 static Eina_Bool
_ecore_evas_extn_socket_prepare(Ecore_Evas * ee)1517 _ecore_evas_extn_socket_prepare(Ecore_Evas *ee)
1518 {
1519 Extn *extn;
1520 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1521 void *pixels = NULL;
1522
1523 extn = bdata->data;
1524 if (!extn) return EINA_FALSE;
1525
1526 if (extn->b[extn->cur_b].buf)
1527 {
1528 pixels = _extnbuf_lock(extn->b[extn->cur_b].buf, NULL, NULL, NULL);
1529 if (pixels)
1530 {
1531 bdata->pixels = pixels;
1532 return EINA_TRUE;
1533 }
1534 }
1535 return EINA_FALSE;
1536 }
1537
1538 static void
_ecore_evas_ews_update_image(void * data,Evas * e EINA_UNUSED,void * event_info)1539 _ecore_evas_ews_update_image(void *data, Evas *e EINA_UNUSED, void *event_info)
1540 {
1541 Evas_Event_Render_Post *post = event_info;
1542 Ecore_Evas *ee = data;
1543 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1544 Extn *extn = bdata->data;
1545 Ecore_Ipc_Client *client;
1546 Eina_Rectangle *r;
1547 Eina_List *l;
1548 int prev_b;
1549
1550 prev_b = extn->prev_b;
1551 _extnbuf_unlock(extn->b[prev_b].buf);
1552
1553 if (post->updated_area)
1554 {
1555 EINA_LIST_FOREACH(post->updated_area, l, r)
1556 {
1557 Ipc_Data_Update ipc;
1558 Eina_List *ll;
1559
1560 ipc.x = r->x;
1561 ipc.y = r->y;
1562 ipc.w = r->w;
1563 ipc.h = r->h;
1564 EINA_LIST_FOREACH(extn->ipc.clients, ll, client)
1565 ecore_ipc_client_send(client, MAJOR, OP_UPDATE, 0, 0, 0, &ipc,
1566 sizeof(ipc));
1567 }
1568
1569 EINA_LIST_FOREACH(extn->ipc.clients, l, client)
1570 ecore_ipc_client_send(client, MAJOR, OP_UPDATE_DONE, 0, 0,
1571 prev_b, NULL, 0);
1572 if (extn->profile.done)
1573 {
1574 _ecore_evas_extn_socket_window_profile_change_done_send(ee);
1575 extn->profile.done = EINA_FALSE;
1576 }
1577 }
1578 }
1579
1580 static Eina_Bool
_ipc_client_add(void * data,int type EINA_UNUSED,void * event)1581 _ipc_client_add(void *data, int type EINA_UNUSED, void *event)
1582 {
1583 Ecore_Ipc_Event_Client_Add *e = event;
1584 Ecore_Evas *ee = data;
1585 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1586 Extn *extn;
1587 Ipc_Data_Resize ipc;
1588 Ipc_Data_Update ipc2;
1589 int i, prev_b;
1590
1591 if (ee != ecore_ipc_server_data_get(ecore_ipc_client_server_get(e->client)))
1592 return ECORE_CALLBACK_PASS_ON;
1593 if (!eina_list_data_find(extn_ee_list, ee))
1594 return ECORE_CALLBACK_PASS_ON;
1595 extn = bdata->data;
1596 if (!extn) return ECORE_CALLBACK_PASS_ON;
1597
1598 extn->ipc.clients = eina_list_append(extn->ipc.clients, e->client);
1599
1600 for (i = 0; i < NBUF; i++)
1601 {
1602 const char *lock;
1603
1604 ecore_ipc_client_send(e->client, MAJOR, OP_SHM_REF0,
1605 extn->svc.num, extn->b[i].num, i,
1606 extn->svc.name,
1607 strlen(extn->svc.name) + 1);
1608 lock = _extnbuf_lock_file_get(extn->b[i].buf);
1609 ecore_ipc_client_send(e->client, MAJOR, OP_SHM_REF1,
1610 ee->w, ee->h, i,
1611 lock, strlen(lock) + 1);
1612 ecore_ipc_client_send(e->client, MAJOR, OP_SHM_REF2,
1613 ee->alpha, extn->svc.sys, i,
1614 NULL, 0);
1615 }
1616 ipc.w = ee->w; ipc.h = ee->h;
1617 ecore_ipc_client_send(e->client, MAJOR, OP_RESIZE,
1618 0, 0, 0, &ipc, sizeof(ipc));
1619 ipc2.x = 0; ipc2.y = 0; ipc2.w = ee->w; ipc2.h = ee->h;
1620 ecore_ipc_client_send(e->client, MAJOR, OP_UPDATE, 0, 0, 0, &ipc2,
1621 sizeof(ipc2));
1622 prev_b = extn->prev_b;
1623 ecore_ipc_client_send(e->client, MAJOR, OP_UPDATE_DONE, 0, 0,
1624 prev_b, NULL, 0);
1625 _ecore_evas_extn_event(ee, ECORE_EVAS_EXTN_CLIENT_ADD);
1626 return ECORE_CALLBACK_PASS_ON;
1627 }
1628
1629 static Eina_Bool
_ipc_client_del(void * data,int type EINA_UNUSED,void * event)1630 _ipc_client_del(void *data, int type EINA_UNUSED, void *event)
1631 {
1632 Ecore_Ipc_Event_Client_Del *e = event;
1633 Ecore_Evas *ee = data;
1634 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1635 Extn *extn;
1636 extn = bdata->data;
1637 if (!extn) return ECORE_CALLBACK_PASS_ON;
1638 if (!eina_list_data_find(extn->ipc.clients, e->client)) return ECORE_CALLBACK_PASS_ON;
1639
1640 extn->ipc.clients = eina_list_remove(extn->ipc.clients, e->client);
1641 extn->ipc.visible_clients = eina_list_remove(extn->ipc.visible_clients, e->client);
1642
1643 _ecore_evas_extn_event(ee, ECORE_EVAS_EXTN_CLIENT_DEL);
1644 return ECORE_CALLBACK_PASS_ON;
1645 }
1646
1647 static Eina_Bool
_ipc_client_data(void * data,int type EINA_UNUSED,void * event)1648 _ipc_client_data(void *data, int type EINA_UNUSED, void *event)
1649 {
1650 Ecore_Ipc_Event_Client_Data *e = event;
1651 Ecore_Evas *ee = data;
1652 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1653 Extn *extn;
1654
1655 if (ee != ecore_ipc_server_data_get(ecore_ipc_client_server_get(e->client)))
1656 return ECORE_CALLBACK_PASS_ON;
1657 if (!eina_list_data_find(extn_ee_list, ee))
1658 return ECORE_CALLBACK_PASS_ON;
1659 extn = bdata->data;
1660 if (!extn) return ECORE_CALLBACK_PASS_ON;
1661 if (e->major != MAJOR)
1662 return ECORE_CALLBACK_PASS_ON;
1663 switch (e->minor)
1664 {
1665 case OP_RESIZE:
1666 if ((e->data) && (e->size >= (int)sizeof(Ipc_Data_Resize)))
1667 {
1668
1669 Ipc_Data_Resize *ipc = e->data;
1670 /* create callbacke data size changed */
1671 _ecore_evas_socket_resize(ee, ipc->w, ipc->h);
1672 }
1673 break;
1674 case OP_SHOW:
1675 if (!ee->visible)
1676 {
1677 if (!eina_list_data_find(extn->ipc.visible_clients, e->client))
1678 extn->ipc.visible_clients = eina_list_append(extn->ipc.visible_clients, e->client);
1679 ee->prop.withdrawn = EINA_FALSE;
1680 if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
1681 ee->visible = 1;
1682 if (ee->func.fn_show) ee->func.fn_show(ee);
1683 }
1684 break;
1685 case OP_HIDE:
1686 if (ee->visible)
1687 {
1688 extn->ipc.visible_clients = eina_list_remove(extn->ipc.visible_clients, e->client);
1689 if (!eina_list_count(extn->ipc.visible_clients))
1690 {
1691 ee->prop.withdrawn = EINA_TRUE;
1692 if (ee->func.fn_state_change) ee->func.fn_state_change(ee);
1693 ee->visible = 0;
1694 if (ee->func.fn_hide) ee->func.fn_hide(ee);
1695 }
1696 }
1697 break;
1698 case OP_FOCUS:
1699 if (!ecore_evas_focus_device_get(ee, NULL)) _ecore_evas_focus_device_set(ee, NULL, EINA_TRUE);
1700 break;
1701 case OP_UNFOCUS:
1702 if (ecore_evas_focus_device_get(ee, NULL)) _ecore_evas_focus_device_set(ee, NULL, EINA_FALSE);
1703 break;
1704 case OP_EV_MOUSE_IN:
1705 if (ee->events_block) break;
1706 if (e->size >= (int)sizeof(Ipc_Data_Ev_Mouse_In))
1707 {
1708 Ipc_Data_Ev_Mouse_In *ipc = e->data;
1709 Evas_Event_Flags flags;
1710
1711 flags = evas_event_default_flags_get(ee->evas);
1712 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1713 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1714 evas_event_feed_mouse_in(ee->evas, ipc->timestamp, NULL);
1715 evas_event_default_flags_set(ee->evas, flags);
1716 }
1717 break;
1718 case OP_EV_MOUSE_OUT:
1719 if (ee->events_block) break;
1720 if (e->size >= (int)sizeof(Ipc_Data_Ev_Mouse_Out))
1721 {
1722 Ipc_Data_Ev_Mouse_Out *ipc = e->data;
1723 Evas_Event_Flags flags;
1724
1725 flags = evas_event_default_flags_get(ee->evas);
1726 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1727 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1728 evas_event_feed_mouse_out(ee->evas, ipc->timestamp, NULL);
1729 evas_event_default_flags_set(ee->evas, flags);
1730 }
1731 break;
1732 case OP_EV_MOUSE_UP:
1733 if (ee->events_block) break;
1734 if (e->size >= (int)sizeof(Ipc_Data_Ev_Mouse_Up))
1735 {
1736 Ipc_Data_Ev_Mouse_Up *ipc = e->data;
1737 Evas_Event_Flags flags;
1738
1739 flags = evas_event_default_flags_get(ee->evas);
1740 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1741 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1742 evas_event_feed_mouse_up(ee->evas, ipc->b, ipc->flags, ipc->timestamp, NULL);
1743 evas_event_default_flags_set(ee->evas, flags);
1744 }
1745 break;
1746 case OP_EV_MOUSE_DOWN:
1747 if (ee->events_block) break;
1748 if (e->size >= (int)sizeof(Ipc_Data_Ev_Mouse_Down))
1749 {
1750 Ipc_Data_Ev_Mouse_Up *ipc = e->data;
1751 Evas_Event_Flags flags;
1752
1753 flags = evas_event_default_flags_get(ee->evas);
1754 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1755 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1756 evas_event_feed_mouse_down(ee->evas, ipc->b, ipc->flags, ipc->timestamp, NULL);
1757 evas_event_default_flags_set(ee->evas, flags);
1758 }
1759 break;
1760 case OP_EV_MOUSE_MOVE:
1761 if (ee->events_block) break;
1762 if (e->size >= (int)sizeof(Ipc_Data_Ev_Mouse_Move))
1763 {
1764 Ipc_Data_Ev_Mouse_Move *ipc = e->data;
1765 Evas_Event_Flags flags;
1766
1767 flags = evas_event_default_flags_get(ee->evas);
1768 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1769 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1770 evas_event_feed_mouse_move(ee->evas, ipc->x, ipc->y, ipc->timestamp, NULL);
1771 evas_event_default_flags_set(ee->evas, flags);
1772 }
1773 break;
1774 case OP_EV_MOUSE_WHEEL:
1775 if (ee->events_block) break;
1776 if (e->size >= (int)sizeof(Ipc_Data_Ev_Mouse_Wheel))
1777 {
1778 Ipc_Data_Ev_Mouse_Wheel *ipc = e->data;
1779 Evas_Event_Flags flags;
1780
1781 flags = evas_event_default_flags_get(ee->evas);
1782 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1783 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1784 evas_event_feed_mouse_wheel(ee->evas, ipc->direction, ipc->z, ipc->timestamp, NULL);
1785 evas_event_default_flags_set(ee->evas, flags);
1786 }
1787 break;
1788 case OP_EV_MULTI_UP:
1789 if (ee->events_block) break;
1790 if (e->size >= (int)sizeof(Ipc_Data_Ev_Multi_Up))
1791 {
1792 Ipc_Data_Ev_Multi_Up *ipc = e->data;
1793 Evas_Event_Flags flags;
1794
1795 flags = evas_event_default_flags_get(ee->evas);
1796 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1797 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1798 evas_event_feed_multi_up(ee->evas, ipc->d, ipc->x, ipc->y, ipc->rad, ipc->radx, ipc->rady, ipc->pres, ipc->ang, ipc->fx, ipc->fy, ipc->flags, ipc->timestamp, NULL);
1799 evas_event_default_flags_set(ee->evas, flags);
1800 }
1801 break;
1802 case OP_EV_MULTI_DOWN:
1803 if (ee->events_block) break;
1804 if (e->size >= (int)sizeof(Ipc_Data_Ev_Multi_Down))
1805 {
1806 Ipc_Data_Ev_Multi_Down *ipc = e->data;
1807 Evas_Event_Flags flags;
1808
1809 flags = evas_event_default_flags_get(ee->evas);
1810 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1811 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1812 evas_event_feed_multi_down(ee->evas, ipc->d, ipc->x, ipc->y, ipc->rad, ipc->radx, ipc->rady, ipc->pres, ipc->ang, ipc->fx, ipc->fy, ipc->flags, ipc->timestamp, NULL);
1813 evas_event_default_flags_set(ee->evas, flags);
1814 }
1815 break;
1816 case OP_EV_MULTI_MOVE:
1817 if (ee->events_block) break;
1818 if (e->size >= (int)sizeof(Ipc_Data_Ev_Multi_Move))
1819 {
1820 Ipc_Data_Ev_Multi_Move *ipc = e->data;
1821 Evas_Event_Flags flags;
1822
1823 flags = evas_event_default_flags_get(ee->evas);
1824 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1825 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1826 evas_event_feed_multi_move(ee->evas, ipc->d, ipc->x, ipc->y, ipc->rad, ipc->radx, ipc->rady, ipc->pres, ipc->ang, ipc->fx, ipc->fy, ipc->timestamp, NULL);
1827 evas_event_default_flags_set(ee->evas, flags);
1828 }
1829 break;
1830
1831 #define STRGET(val) \
1832 do { \
1833 if ((ipc->val) && (ipc->val < (char *)(long)(e->size - 1))) \
1834 ipc->val = ((char *)ipc) + (long)ipc->val; \
1835 else \
1836 ipc->val = NULL; \
1837 } while (0)
1838
1839 case OP_EV_KEY_UP:
1840 if (e->size >= (int)sizeof(Ipc_Data_Ev_Key_Up))
1841 {
1842 if ((e->data) && (e->size > 0) &&
1843 (((unsigned char *)e->data)[e->size - 1] == 0))
1844 {
1845 Ipc_Data_Ev_Key_Up *ipc = e->data;
1846 Evas_Event_Flags flags;
1847
1848 STRGET(keyname);
1849 STRGET(key);
1850 STRGET(string);
1851 STRGET(compose);
1852 flags = evas_event_default_flags_get(ee->evas);
1853 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1854 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1855 evas_event_feed_key_up(ee->evas, ipc->keyname, ipc->key, ipc->string, ipc->compose, ipc->timestamp, NULL);
1856 evas_event_default_flags_set(ee->evas, flags);
1857 }
1858 }
1859 break;
1860 case OP_EV_KEY_DOWN:
1861 if (e->size >= (int)sizeof(Ipc_Data_Ev_Key_Down))
1862 {
1863 if ((e->data) && (e->size > 0) &&
1864 (((unsigned char *)e->data)[e->size - 1] == 0))
1865 {
1866 Ipc_Data_Ev_Key_Down *ipc = e->data;
1867 Evas_Event_Flags flags;
1868
1869 STRGET(keyname);
1870 STRGET(key);
1871 STRGET(string);
1872 STRGET(compose);
1873 flags = evas_event_default_flags_get(ee->evas);
1874 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1875 _ecore_evas_modifiers_locks_mask_set(ee->evas, ipc->mask);
1876 evas_event_feed_key_down(ee->evas, ipc->keyname, ipc->key, ipc->string, ipc->compose, ipc->timestamp, NULL);
1877 evas_event_default_flags_set(ee->evas, flags);
1878 }
1879 }
1880 break;
1881 case OP_EV_HOLD:
1882 if (e->size >= (int)sizeof(Ipc_Data_Ev_Hold))
1883 {
1884 Ipc_Data_Ev_Hold *ipc = e->data;
1885 Evas_Event_Flags flags;
1886
1887 flags = evas_event_default_flags_get(ee->evas);
1888 evas_event_default_flags_set(ee->evas, ipc->event_flags);
1889 evas_event_feed_hold(ee->evas, ipc->hold, ipc->timestamp, NULL);
1890 evas_event_default_flags_set(ee->evas, flags);
1891 }
1892 break;
1893 case OP_PROFILE_CHANGE_REQUEST:
1894 if ((e->data) && (e->size > 0) &&
1895 (((unsigned char *)e->data)[e->size - 1] == 0))
1896 {
1897 _ecore_evas_window_profile_free(ee);
1898 ee->prop.profile.name = (char *)eina_stringshare_add(e->data);
1899
1900 if (ee->func.fn_state_change)
1901 ee->func.fn_state_change(ee);
1902
1903 extn->profile.done = EINA_TRUE;
1904 }
1905 break;
1906 case OP_MSG:
1907 if ((e->data) && (e->size > 0))
1908 {
1909 //ref = msg_domain
1910 //ref_to = msg_id
1911 if (ee->func.fn_msg_parent_handle)
1912 {
1913 INF("Message parent handle: ref=%d to=%d size=%d", e->ref, e->ref_to, e->size);
1914 ee->func.fn_msg_parent_handle(ee, e->ref, e->ref_to, e->data, e->size);
1915 }
1916 }
1917 break;
1918 default:
1919 break;
1920 }
1921 return ECORE_CALLBACK_PASS_ON;
1922 }
1923
1924 static void
_ecore_evas_extn_socket_alpha_set(Ecore_Evas * ee,int alpha)1925 _ecore_evas_extn_socket_alpha_set(Ecore_Evas *ee, int alpha)
1926 {
1927 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
1928 Extn *extn;
1929 Eina_List *l;
1930 Ecore_Ipc_Client *client;
1931
1932 if (((ee->alpha) && (alpha)) || ((!ee->alpha) && (!alpha))) return;
1933 ee->alpha = alpha;
1934
1935 extn = bdata->data;
1936 if (extn)
1937 {
1938 Evas_Engine_Info_Buffer *einfo;
1939
1940 einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
1941 if (einfo)
1942 {
1943 if (ee->alpha)
1944 einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
1945 else
1946 einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_RGB32;
1947 if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
1948 ERR("Cannot set ecore_evas_ext alpha");
1949 evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
1950 }
1951 EINA_LIST_FOREACH(extn->ipc.clients, l, client)
1952 {
1953 int i;
1954
1955 for (i = 0; i < NBUF; i++)
1956 {
1957 const char *lock;
1958
1959 ecore_ipc_client_send(client, MAJOR, OP_SHM_REF0,
1960 extn->svc.num, extn->b[i].num, i,
1961 extn->svc.name,
1962 strlen(extn->svc.name) + 1);
1963 lock = _extnbuf_lock_file_get(extn->b[i].buf);
1964 ecore_ipc_client_send(client, MAJOR, OP_SHM_REF1,
1965 ee->w, ee->h, i,
1966 lock, strlen(lock) + 1);
1967 ecore_ipc_client_send(client, MAJOR, OP_SHM_REF2,
1968 ee->alpha, extn->svc.sys, i,
1969 NULL, 0);
1970 }
1971 }
1972 }
1973 }
1974
1975 static void
_ecore_evas_extn_socket_profile_set(Ecore_Evas * ee,const char * profile)1976 _ecore_evas_extn_socket_profile_set(Ecore_Evas *ee, const char *profile)
1977 {
1978 _ecore_evas_window_profile_free(ee);
1979 ee->prop.profile.name = NULL;
1980
1981 if (profile)
1982 {
1983 ee->prop.profile.name = (char *)eina_stringshare_add(profile);
1984
1985 if (ee->func.fn_state_change)
1986 ee->func.fn_state_change(ee);
1987 }
1988 }
1989
1990 static void
_ecore_evas_extn_socket_available_profiles_set(Ecore_Evas * ee,const char ** plist,int n)1991 _ecore_evas_extn_socket_available_profiles_set(Ecore_Evas *ee, const char **plist, int n)
1992 {
1993 int i;
1994 _ecore_evas_window_available_profiles_free(ee);
1995 ee->prop.profile.available_list = NULL;
1996
1997 if ((plist) && (n >= 1))
1998 {
1999 ee->prop.profile.available_list = calloc(n, sizeof(char *));
2000 if (ee->prop.profile.available_list)
2001 {
2002 for (i = 0; i < n; i++)
2003 ee->prop.profile.available_list[i] = (char *)eina_stringshare_add(plist[i]);
2004 ee->prop.profile.count = n;
2005
2006 if (ee->func.fn_state_change)
2007 ee->func.fn_state_change(ee);
2008 }
2009 }
2010 }
2011
2012 static void
_ecore_evas_extn_socket_msg_send(Ecore_Evas * ee,int msg_domain,int msg_id,void * data,int size)2013 _ecore_evas_extn_socket_msg_send(Ecore_Evas *ee, int msg_domain, int msg_id, void *data, int size)
2014 {
2015 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
2016 Extn *extn;
2017 Eina_List *l;
2018 Ecore_Ipc_Client *client;
2019
2020 extn = bdata->data;
2021 if (extn)
2022 {
2023 EINA_LIST_FOREACH(extn->ipc.clients, l, client)
2024 ecore_ipc_client_send(client, MAJOR, OP_MSG_PARENT,
2025 msg_domain, msg_id, 0,
2026 data,
2027 size);
2028 }
2029 }
2030
2031 static const Ecore_Evas_Engine_Func _ecore_extn_socket_engine_func =
2032 {
2033 _ecore_evas_extn_free,
2034 NULL,
2035 NULL,
2036 NULL,
2037 NULL,
2038 NULL,
2039 NULL,
2040 NULL,
2041 NULL,
2042 NULL,
2043 NULL,
2044 NULL,
2045 NULL,
2046 NULL,
2047 NULL,
2048 NULL,
2049 NULL,
2050 _ecore_evas_socket_resize,
2051 _ecore_evas_socket_move_resize,
2052 NULL,
2053 NULL,
2054 NULL,
2055 NULL,
2056 NULL,
2057 NULL,
2058 NULL,
2059 NULL,
2060 NULL,
2061 NULL,
2062 NULL,
2063 NULL,
2064 NULL,
2065 NULL,
2066 NULL,
2067 NULL,
2068 NULL,
2069 NULL,
2070 NULL,
2071 NULL,
2072 NULL,
2073 NULL,
2074 NULL,
2075 NULL,
2076 NULL,
2077 NULL,
2078 _ecore_evas_extn_socket_alpha_set,
2079 NULL, //transparent
2080 _ecore_evas_extn_socket_available_profiles_set,
2081 _ecore_evas_extn_socket_profile_set,
2082
2083 NULL,
2084 NULL,
2085 NULL,
2086 NULL,
2087 NULL,
2088 NULL,
2089
2090 NULL, // render
2091 NULL, // screen_geometry_get
2092 NULL, // screen_dpi_get
2093 NULL,
2094 _ecore_evas_extn_socket_msg_send,
2095
2096 /* 1.8 abstractions */
2097 NULL, // pointer_xy_get
2098 NULL, // pointer_warp
2099
2100 NULL, // wm_rot_preferred_rotation_set
2101 NULL, // wm_rot_available_rotations_set
2102 NULL, // wm_rot_manual_rotation_done_set
2103 NULL, // wm_rot_manual_rotation_done
2104
2105 NULL, // aux_hints_set
2106
2107 NULL, // fn_animator_register
2108 NULL, // fn_animator_unregister
2109
2110 NULL, // fn_evas_changed
2111 NULL, //fn_focus_device_set
2112 NULL, //fn_callback_focus_device_in_set
2113 NULL, //fn_callback_focus_device_out_set
2114 NULL, //fn_callback_device_mouse_in_set
2115 NULL, //fn_callback_device_mouse_out_set
2116 NULL, //fn_pointer_device_xy_get
2117 _ecore_evas_extn_socket_prepare,
2118 NULL //fn_last_tick_get
2119 };
2120
2121 EAPI Ecore_Evas *
ecore_evas_extn_socket_new_internal(int w,int h)2122 ecore_evas_extn_socket_new_internal(int w, int h)
2123 {
2124 Evas_Engine_Info_Buffer *einfo;
2125 Ecore_Evas_Interface_Extn *iface;
2126 Ecore_Evas_Engine_Buffer_Data *bdata;
2127 Ecore_Evas *ee;
2128 int rmethod;
2129
2130 rmethod = evas_render_method_lookup("buffer");
2131 if (!rmethod) return NULL;
2132 ee = calloc(1, sizeof(Ecore_Evas));
2133 if (!ee) return NULL;
2134 bdata = calloc(1, sizeof(Ecore_Evas_Engine_Buffer_Data));
2135 if (!bdata)
2136 {
2137 free(ee);
2138 return NULL;
2139 }
2140
2141 ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
2142
2143 ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_extn_socket_engine_func;
2144 ee->engine.data = bdata;
2145
2146 ee->driver = "extn_socket";
2147
2148 iface = _ecore_evas_extn_interface_new();
2149 ee->engine.ifaces = eina_list_append(ee->engine.ifaces, iface);
2150
2151 ee->rotation = 0;
2152 ee->visible = 1;
2153 ee->w = w;
2154 ee->h = h;
2155 ee->req.w = ee->w;
2156 ee->req.h = ee->h;
2157 ee->profile_supported = 1; /* to accept the profile change request from the client(plug) */
2158
2159 ee->prop.max.w = 0;
2160 ee->prop.max.h = 0;
2161 ee->prop.layer = 0;
2162 ee->prop.borderless = EINA_TRUE;
2163 ee->prop.override = EINA_TRUE;
2164 ee->prop.maximized = EINA_FALSE;
2165 ee->prop.fullscreen = EINA_FALSE;
2166 ee->prop.withdrawn = EINA_FALSE;
2167 ee->prop.sticky = EINA_FALSE;
2168
2169 /* init evas here */
2170 if (!ecore_evas_evas_new(ee, w, h))
2171 {
2172 ERR("Failed to create the canvas.");
2173 ecore_evas_free(ee);
2174 return NULL;
2175 }
2176 evas_output_method_set(ee->evas, rmethod);
2177 evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_POST, _ecore_evas_ews_update_image, ee);
2178
2179 einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
2180 if (einfo)
2181 {
2182 if (ee->alpha)
2183 einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
2184 else
2185 einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_RGB32;
2186 einfo->info.dest_buffer = NULL;
2187 einfo->info.dest_buffer_row_bytes = 0;
2188 einfo->info.use_color_key = 0;
2189 einfo->info.alpha_threshold = 0;
2190 einfo->info.func.new_update_region = NULL;
2191 einfo->info.func.free_update_region = NULL;
2192 einfo->info.func.switch_buffer = _ecore_evas_socket_switch;
2193 einfo->info.switch_data = ee;
2194 if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
2195 {
2196 ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
2197 ecore_evas_free(ee);
2198 return NULL;
2199 }
2200 }
2201 else
2202 {
2203 ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
2204 ecore_evas_free(ee);
2205 return NULL;
2206 }
2207 evas_key_modifier_add(ee->evas, "Shift");
2208 evas_key_modifier_add(ee->evas, "Control");
2209 evas_key_modifier_add(ee->evas, "Alt");
2210 evas_key_modifier_add(ee->evas, "Meta");
2211 evas_key_modifier_add(ee->evas, "Hyper");
2212 evas_key_modifier_add(ee->evas, "Super");
2213 evas_key_lock_add(ee->evas, "Caps_Lock");
2214 evas_key_lock_add(ee->evas, "Num_Lock");
2215 evas_key_lock_add(ee->evas, "Scroll_Lock");
2216
2217 extn_ee_list = eina_list_append(extn_ee_list, ee);
2218
2219 _ecore_evas_register(ee);
2220
2221 return ee;
2222 }
2223
2224 Eina_Bool
_ecore_evas_extn_socket_listen(Ecore_Evas * ee,const char * svcname,int svcnum,Eina_Bool svcsys)2225 _ecore_evas_extn_socket_listen(Ecore_Evas *ee, const char *svcname, int svcnum, Eina_Bool svcsys)
2226 {
2227 Extn *extn;
2228 Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
2229
2230 extn = calloc(1, sizeof(Extn));
2231 if (!extn)
2232 {
2233 return EINA_FALSE;
2234 }
2235 else
2236 {
2237 Ecore_Ipc_Type ipctype = ECORE_IPC_LOCAL_USER;
2238 int i;
2239 int last_try = 0;
2240
2241 ecore_ipc_init();
2242 extn->svc.name = eina_stringshare_add(svcname);
2243 extn->svc.num = svcnum;
2244 extn->svc.sys = svcsys;
2245
2246 for (i = 0; i < NBUF; i++)
2247 {
2248 do
2249 {
2250 extn->b[i].buf = _extnbuf_new(extn->svc.name, extn->svc.num,
2251 extn->svc.sys, last_try,
2252 ee->w, ee->h, EINA_TRUE);
2253 if (extn->b[i].buf) extn->b[i].num = last_try;
2254 last_try++;
2255 if (last_try > 1024) break;
2256 }
2257 while (!extn->b[i].buf);
2258
2259 }
2260
2261 if (extn->b[extn->cur_b].buf)
2262 bdata->pixels = _extnbuf_data_get(extn->b[extn->cur_b].buf,
2263 NULL, NULL, NULL);
2264 else
2265 {
2266 eina_stringshare_del(extn->svc.name);
2267 free(extn);
2268 ecore_ipc_shutdown();
2269 return EINA_FALSE;
2270 }
2271
2272 if (extn->svc.sys) ipctype = ECORE_IPC_LOCAL_SYSTEM;
2273 extn->ipc.server = ecore_ipc_server_add(ipctype,
2274 (char *)extn->svc.name,
2275 extn->svc.num, ee);
2276 if (!extn->ipc.server)
2277 {
2278 for (i = 0; i < NBUF; i++)
2279 {
2280 if (extn->b[i].buf) _extnbuf_free(extn->b[i].buf);
2281 if (extn->b[i].obuf) _extnbuf_free(extn->b[i].obuf);
2282 if (extn->b[i].base) eina_stringshare_del(extn->b[i].base);
2283 if (extn->b[i].lock) eina_stringshare_del(extn->b[i].lock);
2284 extn->b[i].buf = NULL;
2285 extn->b[i].obuf = NULL;
2286 extn->b[i].base = NULL;
2287 extn->b[i].lock = NULL;
2288 }
2289 eina_stringshare_del(extn->svc.name);
2290 free(extn);
2291 ecore_ipc_shutdown();
2292 return EINA_FALSE;
2293 }
2294 bdata->data = extn;
2295 extn->ipc.handlers = eina_list_append
2296 (extn->ipc.handlers,
2297 ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_ADD,
2298 _ipc_client_add, ee));
2299 extn->ipc.handlers = eina_list_append
2300 (extn->ipc.handlers,
2301 ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DEL,
2302 _ipc_client_del, ee));
2303 extn->ipc.handlers = eina_list_append
2304 (extn->ipc.handlers,
2305 ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DATA,
2306 _ipc_client_data, ee));
2307 }
2308 return EINA_TRUE;
2309 }
2310
2311 static Ecore_Evas_Interface_Extn *
_ecore_evas_extn_interface_new(void)2312 _ecore_evas_extn_interface_new(void)
2313 {
2314 Ecore_Evas_Interface_Extn *iface;
2315
2316 iface = calloc(1, sizeof(Ecore_Evas_Interface_Extn));
2317 if (!iface) return NULL;
2318
2319 iface->base.name = interface_extn_name;
2320 iface->base.version = interface_extn_version;
2321
2322 iface->connect = _ecore_evas_extn_plug_connect;
2323 iface->listen = _ecore_evas_extn_socket_listen;
2324
2325 return iface;
2326 }
2327
2328 EAPI void
ecore_evas_extn_socket_events_block_set_internal(Ecore_Evas * ee,Eina_Bool events_block)2329 ecore_evas_extn_socket_events_block_set_internal(Ecore_Evas *ee, Eina_Bool events_block)
2330 {
2331 ee->events_block = events_block;
2332 }
2333
2334 EAPI Eina_Bool
ecore_evas_extn_socket_events_block_get_internal(Ecore_Evas * ee)2335 ecore_evas_extn_socket_events_block_get_internal(Ecore_Evas *ee)
2336 {
2337 return ee->events_block;
2338 }
2339
2340 EINA_MODULE_INIT(_ecore_evas_extn_module_init);
2341 EINA_MODULE_SHUTDOWN(_ecore_evas_extn_module_shutdown);
2342