diff options
author | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
---|---|---|
committer | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
commit | 07274513e984f0b5544586c74508ccd16e7dcafa (patch) | |
tree | b32ff2a9136fbc1a4a6a0ed1e4d79cde0f5f16d9 /libraries/ecore/src/lib/ecore_evas/ecore_evas_extn.c | |
parent | Added Irrlicht 1.8, but without all the Windows binaries. (diff) | |
download | SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.zip SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.gz SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.bz2 SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.xz |
Remove EFL, since it's been released now.
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.c | 2169 |
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 | |||
37 | typedef struct _Shmfile Shmfile; | ||
38 | |||
39 | struct _Shmfile | ||
40 | { | ||
41 | int fd; | ||
42 | int size; | ||
43 | void *addr; | ||
44 | const char *file; | ||
45 | }; | ||
46 | |||
47 | static int blank = 0x00000000; | ||
48 | |||
49 | static Shmfile * | ||
50 | shmfile_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 | |||
98 | void | ||
99 | shmfile_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 | |||
108 | static Shmfile * | ||
109 | shmfile_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 | |||
143 | void | ||
144 | shmfile_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 | |||
155 | enum // 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 | |||
180 | enum | ||
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 | |||
193 | typedef struct _Ipc_Data_Resize Ipc_Data_Resize; | ||
194 | typedef struct _Ipc_Data_Update Ipc_Data_Update; | ||
195 | typedef struct _Ipc_Data_Ev_Mouse_In Ipc_Data_Ev_Mouse_In; | ||
196 | typedef struct _Ipc_Data_Ev_Mouse_Out Ipc_Data_Ev_Mouse_Out; | ||
197 | typedef struct _Ipc_Data_Ev_Mouse_Up Ipc_Data_Ev_Mouse_Up; | ||
198 | typedef struct _Ipc_Data_Ev_Mouse_Down Ipc_Data_Ev_Mouse_Down; | ||
199 | typedef struct _Ipc_Data_Ev_Mouse_Move Ipc_Data_Ev_Mouse_Move; | ||
200 | typedef struct _Ipc_Data_Ev_Mouse_Wheel Ipc_Data_Ev_Mouse_Wheel; | ||
201 | typedef struct _Ipc_Data_Ev_Hold Ipc_Data_Ev_Hold; | ||
202 | typedef struct _Ipc_Data_Ev_Multi_Up Ipc_Data_Ev_Multi_Up; | ||
203 | typedef struct _Ipc_Data_Ev_Multi_Down Ipc_Data_Ev_Multi_Down; | ||
204 | typedef struct _Ipc_Data_Ev_Multi_Move Ipc_Data_Ev_Multi_Move; | ||
205 | typedef struct _Ipc_Data_Ev_Key_Up Ipc_Data_Ev_Key_Up; | ||
206 | typedef struct _Ipc_Data_Ev_Key_Down Ipc_Data_Ev_Key_Down; | ||
207 | |||
208 | struct _Ipc_Data_Resize | ||
209 | { | ||
210 | int w, h; | ||
211 | }; | ||
212 | |||
213 | struct _Ipc_Data_Update | ||
214 | { | ||
215 | int x, w, y, h; | ||
216 | }; | ||
217 | |||
218 | struct _Ipc_Data_Ev_Mouse_In | ||
219 | { | ||
220 | unsigned int timestamp; | ||
221 | int mask; | ||
222 | Evas_Event_Flags event_flags; | ||
223 | }; | ||
224 | |||
225 | struct _Ipc_Data_Ev_Mouse_Out | ||
226 | { | ||
227 | unsigned int timestamp; | ||
228 | int mask; | ||
229 | Evas_Event_Flags event_flags; | ||
230 | }; | ||
231 | |||
232 | struct _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 | |||
241 | struct _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 | |||
250 | struct _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 | |||
259 | struct _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 | |||
268 | struct _Ipc_Data_Ev_Hold | ||
269 | { | ||
270 | int hold; | ||
271 | unsigned int timestamp; | ||
272 | Evas_Event_Flags event_flags; | ||
273 | }; | ||
274 | |||
275 | struct _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 | |||
285 | struct _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 | |||
295 | struct _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 | |||
304 | struct _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 | |||
312 | struct _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 | |||
320 | typedef struct _Extn Extn; | ||
321 | |||
322 | struct _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 | |||
346 | static Eina_List *extn_ee_list = NULL; | ||
347 | |||
348 | EAPI int ECORE_EVAS_EXTN_CLIENT_ADD = 0; | ||
349 | EAPI int ECORE_EVAS_EXTN_CLIENT_DEL = 0; | ||
350 | |||
351 | void | ||
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 | |||
359 | void | ||
360 | _ecore_evas_extn_shutdown(void) | ||
361 | { | ||
362 | } | ||
363 | |||
364 | static 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 | |||
373 | static 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 | |||
383 | static 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 | |||
396 | static 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 | |||
409 | static 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 | |||
416 | static 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 | |||
423 | static 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 | |||
430 | static 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 | |||
468 | static 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 | |||
538 | static 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 | |||
569 | static 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 | |||
575 | static 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 | |||
601 | static 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 | |||
624 | static 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 | |||
644 | static 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 | |||
664 | static 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 | |||
686 | static 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 | |||
708 | static 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 | |||
734 | static 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 | |||
756 | static 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 | |||
792 | static 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 | |||
827 | static 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 | |||
861 | static 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 | |||
870 | static 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 | |||
926 | static 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 | |||
982 | static 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 | |||
1002 | static 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 | |||
1016 | static 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 | |||
1030 | static 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 | |||
1044 | static 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 | |||
1058 | static 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 | |||
1118 | static 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 | |||
1135 | static 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 | |||
1162 | static 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 | ||
1289 | void | ||
1290 | _ecore_evas_extn_init(void) | ||
1291 | { | ||
1292 | } | ||
1293 | |||
1294 | void | ||
1295 | _ecore_evas_extn_shutdown(void) | ||
1296 | { | ||
1297 | } | ||
1298 | |||
1299 | #endif /* BUILD_ECORE_EVAS_EXTN */ | ||
1300 | |||
1301 | EAPI Evas_Object * | ||
1302 | ecore_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 | |||
1418 | EAPI Eina_Bool | ||
1419 | ecore_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 | |||
1469 | EAPI void | ||
1470 | ecore_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 | |||
1481 | EAPI void | ||
1482 | ecore_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 | ||
1494 | static 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 | |||
1563 | static 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 | |||
1569 | int | ||
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 | |||
1616 | static 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 | |||
1651 | static 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 | |||
1667 | static 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 | |||
1909 | static 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 | |||
1942 | static 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 | |||
2004 | EAPI Ecore_Evas * | ||
2005 | ecore_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 | |||
2094 | EAPI Eina_Bool | ||
2095 | ecore_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 | } | ||