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