diff --git a/src/Makefile_Elementary.am b/src/Makefile_Elementary.am index dffd96f9a1..b1ac2657ae 100644 --- a/src/Makefile_Elementary.am +++ b/src/Makefile_Elementary.am @@ -127,6 +127,7 @@ elm_private_eolian_files = \ lib/elementary/efl_ui_focus_parent_provider_gen.eo \ tests/elementary/focus_test.eo \ tests/elementary/focus_test_sub_main.eo \ + lib/elementary/efl_selection_manager.eo \ $(NULL) # Legacy classes - not part of public EO API @@ -226,7 +227,9 @@ elm_legacy_eolian_files = \ elm_eolian_type_files = \ lib/elementary/elm_general.eot \ lib/elementary/efl_ui.eot \ - lib/elementary/efl_ui_list_types.eot + lib/elementary/efl_ui_list_types.eot \ + lib/elementary/efl_selection_types.eot \ + lib/elementary/efl_ui_dnd_types.eot elm_public_eolian_c = $(elm_public_eolian_files:%.eo=%.eo.c) elm_public_eolian_h = $(elm_public_eolian_files:%.eo=%.eo.h) \ @@ -757,6 +760,7 @@ lib_elementary_libelementary_la_SOURCES = \ lib/elementary/efl_ui_scroller.c \ lib/elementary/efl_ui_scroll_manager.c \ lib/elementary/efl_ui_pan.c \ + lib/elementary/efl_selection_manager.c \ $(NULL) diff --git a/src/lib/elementary/Elementary.h b/src/lib/elementary/Elementary.h index da2cc35440..b5c58c77f7 100644 --- a/src/lib/elementary/Elementary.h +++ b/src/lib/elementary/Elementary.h @@ -321,6 +321,8 @@ EAPI extern Elm_Version *elm_version; # include # include # include +# include "efl_selection_types.eot.h" +# include "efl_ui_dnd_types.eot.h" # include #endif diff --git a/src/lib/elementary/efl_selection_manager.c b/src/lib/elementary/efl_selection_manager.c new file mode 100644 index 0000000000..23bde3bded --- /dev/null +++ b/src/lib/elementary/efl_selection_manager.c @@ -0,0 +1,5320 @@ +#ifdef HAVE_CONFIG_H +# include "elementary_config.h" +#endif + +#include +#include "elm_priv.h" +#ifdef HAVE_MMAN_H +# include +#endif + +#include "efl_selection_manager_private.h" + +#define MY_CLASS EFL_SELECTION_MANAGER_CLASS + +#define DEBUGON 1 +#ifdef DEBUGON +# define sel_debug(fmt, args...) fprintf(stderr, __FILE__":%s:%d : " fmt "\n", __FUNCTION__, __LINE__, ##args) +#else +# define sel_debug(x...) do { } while (0) +#endif + +static void _set_selection_list(Sel_Manager_Selection *sel_list, Sel_Manager_Seat_Selection *seat_sel); +static void _anim_data_free(Sel_Manager_Drag_Container *dc); +static void _cont_obj_mouse_move_cb(void *data, Evas *e, Evas_Object *obj, void *event_info); +static void _cont_obj_mouse_up_cb(void *data, Evas *e, Evas_Object *obj, void *event_info); +static void _item_container_del_internal(Sel_Manager_Drag_Container *dc, Eina_Bool full); + +void efl_selection_manager_drop_target_del(Eo *obj, Efl_Object *target_obj, Efl_Selection_Format format, unsigned int seat); +void efl_selection_manager_selection_clear(Eo *obj, Efl_Object *owner, Efl_Selection_Type type, unsigned int seat); +void efl_selection_manager_drag_start(Eo *obj, Efl_Object *drag_obj, Efl_Selection_Format format, Eina_Slice data, Efl_Selection_Action action, void *icon_func_data, Efl_Dnd_Drag_Icon_Create icon_func, Eina_Free_Cb icon_func_free_cb, unsigned int seat); + +#ifdef HAVE_ELEMENTARY_X +static Ecore_X_Atom _x11_dnd_action_rev_map(Efl_Selection_Action action); +static Ecore_X_Window _x11_xwin_get(const Evas_Object *obj); +#endif + +#ifdef HAVE_ELEMENTARY_WL2 +static Ecore_Wl2_Window *_wl_window_get(const Evas_Object *obj); +static Ecore_Wl2_Input *_wl_seat_get(Ecore_Wl2_Window *win, const Evas_Object *obj, unsigned int seat_id); +#endif + +static inline void +_owner_change_check(Efl_Object *owner, Sel_Manager_Seat_Selection *seat_sel, + Sel_Manager_Selection *sel, + Efl_Selection_Type type, Eina_Bool same_win) +{ + if ((sel->owner != NULL) && + (sel->owner != owner) && same_win) + { + Eina_List *l, *l_next; + Sel_Manager_Selection_Lost *sel_lost; + EINA_LIST_FOREACH_SAFE(seat_sel->sel_lost_list, l, l_next, sel_lost) + { + if ((sel_lost->request == sel->owner) && + (sel_lost->type == type)) + { + eina_promise_resolve(sel_lost->promise, eina_value_uint_init(sel_lost->type)); + seat_sel->sel_lost_list = eina_list_remove(seat_sel->sel_lost_list, sel_lost); + free(sel_lost); + } + } + } +} + +static Sel_Manager_Seat_Selection * +_sel_manager_seat_selection_get(Efl_Selection_Manager_Data *pd, unsigned int seat) +{ + Eina_List *l = NULL; + Sel_Manager_Seat_Selection *seat_sel = NULL; + + EINA_LIST_FOREACH(pd->seat_list, l, seat_sel) + { + if (seat_sel->seat == seat) + break; + } + if (!seat_sel) + ERR("Could not find request seat"); + + return seat_sel; +} + +static Sel_Manager_Seat_Selection * +_sel_manager_seat_selection_init(Efl_Selection_Manager_Data *pd, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel = NULL; + Eina_List *l = NULL; + + EINA_LIST_FOREACH(pd->seat_list, l, seat_sel) + { + if(seat_sel->seat == seat) + break; + } + if (!seat_sel) + { + seat_sel = calloc(1, sizeof(Sel_Manager_Seat_Selection)); + if (!seat_sel) + { + ERR("Failed to allocate seat"); + return NULL; + } + seat_sel->saved_types = calloc(1, sizeof(Saved_Type)); + seat_sel->seat = seat; + seat_sel->pd = pd; + pd->seat_list = eina_list_append(pd->seat_list, seat_sel); + } +#ifdef HAVE_ELEMENTARY_X + if (!seat_sel->sel_list) + { + seat_sel->sel_list = calloc(1, (EFL_SELECTION_TYPE_CLIPBOARD + 1) * sizeof(Sel_Manager_Selection)); + if (!seat_sel->sel_list) + { + ERR("failed to allocate selection list"); + return NULL; + } + _set_selection_list(seat_sel->sel_list, seat_sel); + } +#endif +#ifdef HAVE_ELEMENTARY_WL2 + if (!seat_sel->sel) + { + Sel_Manager_Selection *sel = calloc(1, sizeof(Sel_Manager_Selection)); + if (!sel) + { + ERR("failed to allocate selection"); + return NULL; + } + sel->seat_sel = seat_sel; + seat_sel->sel = sel; + } +#endif +#ifdef HAVE_ELEMENTARY_COCOA + if (!seat_sel->sel) + { + Sel_Manager_Selection *sel = calloc(1, sizeof(Sel_Manager_Selection)); + if (!sel) + { + ERR("failed to allocate selection"); + return NULL; + } + sel->seat_sel = seat_sel; + seat_sel->sel = sel; + } +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + if (!seat_sel->sel_list) + { + seat_sel->sel_list = calloc(1, (EFL_SELECTION_TYPE_CLIPBOARD + 1) * sizeof(Sel_Manager_Selection)); + if (!seat_sel->sel_list) + { + ERR("failed to allocate selection list"); + return NULL; + } + _set_selection_list(seat_sel->sel_list, seat_sel); + } +#endif + + return seat_sel; +} + +/* TODO: this should not be an actual tempfile, but rather encode the object + * as http://dataurl.net/ if it's an image or similar. Evas should support + * decoding it as memfile. */ +static Tmp_Info * +_tempfile_new(int size) +{ +#ifdef HAVE_MMAN_H + Tmp_Info *info; + const char *tmppath = NULL; + mode_t cur_umask; + int len; + + info = calloc(1, sizeof(Tmp_Info)); + if (!info) return NULL; +#if defined(HAVE_GETUID) && defined(HAVE_GETEUID) + if (getuid() == geteuid()) +#endif + tmppath = getenv("TMP"); + if (!tmppath) tmppath = P_tmpdir; + len = snprintf(NULL, 0, "%s/%sXXXXXX", tmppath, "elmcnpitem-"); + if (len < 0) goto on_error; + len++; + info->filename = malloc(len); + if (!info->filename) goto on_error; + snprintf(info->filename,len,"%s/%sXXXXXX", tmppath, "elmcnpitem-"); + cur_umask = umask(S_IRWXO | S_IRWXG); + info->fd = mkstemp(info->filename); + umask(cur_umask); + if (info->fd < 0) goto on_error; +# ifdef __linux__ + { + char *tmp; + /* And before someone says anything see POSIX 1003.1-2008 page 400 */ + long pid; + + pid = (long)getpid(); + /* Use pid instead of /proc/self: That way if can be passed around */ + len = snprintf(NULL,0,"/proc/%li/fd/%i", pid, info->fd); + len++; + tmp = malloc(len); + if (tmp) + { + snprintf(tmp,len, "/proc/%li/fd/%i", pid, info->fd); + unlink(info->filename); + free(info->filename); + info->filename = tmp; + } + } +# endif + sel_debug("filename is %s\n", info->filename); + if (size < 1) goto on_error; + /* Map it in */ + if (ftruncate(info->fd, size)) + { + perror("ftruncate"); + goto on_error; + } + eina_mmap_safety_enabled_set(EINA_TRUE); + info->map = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, info->fd, 0); + if (info->map == MAP_FAILED) + { + perror("mmap"); + goto on_error; + } + return info; + + on_error: + if (info->fd >= 0) close(info->fd); + info->fd = -1; + /* Set map to NULL and return */ + info->map = NULL; + info->len = 0; + free(info->filename); + free(info); + return NULL; +#else + (void) size; + return NULL; +#endif +} + +static int +_tmpinfo_free(Tmp_Info *info) +{ + if (!info) return 0; + free(info->filename); + free(info); + return 0; +} + +static void +_all_drop_targets_cbs_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *info EINA_UNUSED) +{ + Efl_Selection_Manager_Data *pd = data; + Sel_Manager_Dropable *dropable = NULL; + + if (!pd) return; + dropable = efl_key_data_get(obj, "__elm_dropable"); + if (dropable) + { + Drop_Format *df; + while (dropable->format_list) + { + df = EINA_INLIST_CONTAINER_GET(dropable->format_list, Drop_Format); + efl_selection_manager_drop_target_del(pd->sel_man, obj, df->format, dropable->seat); + // If drop_target_del() happened to delete dropabale, then + // re-fetch it each loop to make sure it didn't + dropable = efl_key_data_get(obj, "__elm_dropable"); + if (!dropable) break; + } + } +} + +static void +_dropable_coords_adjust(Sel_Manager_Dropable *dropable, Eina_Position2D *pos) +{ + Ecore_Evas *ee; + Evas *evas = evas_object_evas_get(dropable->obj); + int ex = 0, ey = 0, ew = 0, eh = 0; + Evas_Object *win; + + ee = ecore_evas_ecore_evas_get(evas); + ecore_evas_geometry_get(ee, &ex, &ey, &ew, &eh); + pos->x = pos->x - ex; + pos->y = pos->y - ey; + + /* For Wayland, frame coords have to be subtracted. */ + Evas_Coord fx, fy; + evas_output_framespace_get(evas, &fx, &fy, NULL, NULL); + if (fx || fy) sel_debug("evas frame fx %d fy %d\n", fx, fy); + pos->x = pos->x - fx; + pos->y = pos->y - fy; + + if (elm_widget_is(dropable->obj)) + { + win = elm_widget_top_get(dropable->obj); + if (win && efl_isa(win, EFL_UI_WIN_CLASS)) + { + Evas_Coord x2, y2; + int rot = elm_win_rotation_get(win); + switch (rot) + { + case 90: + x2 = ew - pos->y; + y2 = pos->x; + break; + case 180: + x2 = ew - pos->x; + y2 = eh - pos->y; + break; + case 270: + x2 = pos->y; + y2 = eh - pos->x; + break; + default: + x2 = pos->x; + y2 = pos->y; + break; + } + sel_debug("rotation %d, w %d, h %d - x:%d->%d, y:%d->%d\n", + rot, ew, eh, pos->x, x2, pos->y, y2); + pos->x = x2; + pos->y = y2; + } + } +} + +static Eina_Bool +_drag_cancel_animate(void *data, double pos) +{ /* Animation to "move back" drag-window */ + Sel_Manager_Seat_Selection *seat_sel = data; + sel_debug("in, pos: %f", pos); + if (pos >= 0.99) + { +#ifdef HAVE_ELEMENTARY_X + Ecore_X_Window xdragwin = _x11_xwin_get(seat_sel->drag_win); + ecore_x_window_ignore_set(xdragwin, 0); +#endif + ERR("Delete drag_win"); + evas_object_del(seat_sel->drag_win); + seat_sel->drag_win = NULL; + return ECORE_CALLBACK_CANCEL; + } + else + { + int x, y; + x = seat_sel->drag_win_end.x - (pos * (seat_sel->drag_win_end.x - seat_sel->drag_win_start.x)); + y = seat_sel->drag_win_end.y - (pos * (seat_sel->drag_win_end.y - seat_sel->drag_win_start.y)); + evas_object_move(seat_sel->drag_win, x, y); + } + + return ECORE_CALLBACK_RENEW; +} + +static Efl_Selection_Format +_dnd_types_to_format(Efl_Selection_Manager_Data *pd, const char **types, int ntypes) +{ + Efl_Selection_Format ret_type = 0; + int i; + for (i = 0; i < ntypes; i++) + { + Sel_Manager_Atom *atom = eina_hash_find(pd->type_hash, types[i]); + if (atom) ret_type |= atom->format; + } + return ret_type; +} + +static Eina_List * +_dropable_list_geom_find(Efl_Selection_Manager_Data *pd, Evas *evas, Evas_Coord px, Evas_Coord py) +{ + Eina_List *itr, *top_objects_list = NULL, *dropable_list = NULL; + Evas_Object *top_obj; + Sel_Manager_Dropable *dropable = NULL; + + if (!pd->drop_list) return NULL; + + /* We retrieve the (non-smart) objects pointed by (px, py) */ + top_objects_list = evas_tree_objects_at_xy_get(evas, NULL, px, py); + /* We walk on this list from the last because if the list contains more than one + * element, all but the last will repeat events. The last one can repeat events + * or not. Anyway, this last one is the first that has to be taken into account + * for the determination of the drop target. + */ + EINA_LIST_REVERSE_FOREACH(top_objects_list, itr, top_obj) + { + Evas_Object *object = top_obj; + /* We search for the dropable data into the object. If not found, we search into its parent. + * For example, if a button is a drop target, the first object will be an (internal) image. + * The drop target is attached to the button, i.e to image's parent. That's why we need to + * walk on the parents until NULL. + * If we find this dropable data, we found our drop target. + */ + while (object) + { + dropable = efl_key_data_get(object, "__elm_dropable"); + if (dropable) + { + Eina_Bool exist = EINA_FALSE; + Eina_List *l; + Sel_Manager_Dropable *d = NULL; + EINA_LIST_FOREACH(dropable_list, l, d) + { + if (d == dropable) + { + exist = EINA_TRUE; + break; + } + } + if (!exist) + dropable_list = eina_list_append(dropable_list, dropable); + object = evas_object_smart_parent_get(object); + if (dropable) + sel_debug("Drop target %p of type %s found\n", + dropable->obj, efl_class_name_get(efl_class_get(dropable->obj))); + } + else + object = evas_object_smart_parent_get(object); + } + } + eina_list_free(top_objects_list); + return dropable_list; +} + +#ifdef HAVE_ELEMENTARY_X +static Ecore_X_Window +_x11_xwin_get(const Efl_Object *obj) +{ + if (!obj) return 0; + + Ecore_X_Window xwin = 0; + //get top + const Evas_Object *top = obj; + const Evas_Object *parent = obj; + while(parent) + { + top = parent; + parent = efl_parent_get(parent); + } + if (efl_isa(top, EFL_UI_WIN_CLASS)) + { + xwin = elm_win_xwindow_get(top); + } + if (!xwin) + { + Ecore_Evas *ee; + Evas *evas = evas_object_evas_get(obj); + if (!evas) return 0; + ee = ecore_evas_ecore_evas_get(evas); + if (!ee) return 0; + + while(!xwin) + { + const char *engine_name = ecore_evas_engine_name_get(ee); + if (!strcmp(engine_name, ELM_BUFFER)) + { + ee = ecore_evas_buffer_ecore_evas_parent_get(ee); + if (!ee) return 0; + xwin = _elm_ee_xwin_get(ee); + } + else + { + xwin = _elm_ee_xwin_get(ee); + if (!xwin) return 0; + } + } + } + + return xwin; +} + +static Eina_Bool +_x11_is_uri_type_data(Sel_Manager_Selection *sel EINA_UNUSED, Ecore_X_Event_Selection_Notify *notify) +{ + Ecore_X_Selection_Data *data; + char *p; + + data = notify->data; + sel_debug("data->format is %d %p %p", data->format, notify, data); + if (data->content == ECORE_X_SELECTION_CONTENT_FILES) return EINA_TRUE; + p = (char *)data->data; + if (!p) return EINA_TRUE; + sel_debug("Got %s", p); + if (strncmp(p, "file:/", 6)) + { + if (*p != '/') return EINA_FALSE; + } + return EINA_TRUE; +} + +static Sel_Manager_Seat_Selection * +_x11_sel_manager_seat_selection_init(Efl_Selection_Manager_Data *pd, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel = NULL; + Eina_List *l = NULL; + + EINA_LIST_FOREACH(pd->seat_list, l, seat_sel) + { + if(seat_sel->seat == seat) + break; + } + if (!seat_sel) + { + seat_sel = calloc(1, sizeof(Sel_Manager_Seat_Selection)); + if (!seat_sel) + { + ERR("Failed to allocate seat"); + return NULL; + } + seat_sel->saved_types = calloc(1, sizeof(Saved_Type)); + seat_sel->seat = seat; + seat_sel->pd = pd; + pd->seat_list = eina_list_append(pd->seat_list, seat_sel); + } + if (!seat_sel->sel_list) + { + //TODO: reduce memory (may be just need one common sel_list) + seat_sel->sel_list = calloc(1, (EFL_SELECTION_TYPE_CLIPBOARD + 1) * sizeof(Sel_Manager_Selection)); + if (!seat_sel->sel_list) + { + ERR("failed to allocate selection list"); + return NULL; + } + _set_selection_list(seat_sel->sel_list, seat_sel); + } + + return seat_sel; +} + +static Eina_Bool +_x11_data_preparer_text(Sel_Manager_Seat_Selection *seat_sel EINA_UNUSED, + Ecore_X_Event_Selection_Notify *notify, + Efl_Selection_Data *ddata, Tmp_Info **tmp_info EINA_UNUSED) +{ + sel_debug("text data preparer"); + Ecore_X_Selection_Data *data = notify->data; + ddata->format = EFL_SELECTION_FORMAT_TEXT; + ddata->data.mem = eina_memdup(data->data, data->length, EINA_TRUE); + ddata->data.len = data->length; + return EINA_TRUE; +} + +static Eina_Bool +_x11_data_preparer_markup(Sel_Manager_Seat_Selection *seat_sel EINA_UNUSED, + Ecore_X_Event_Selection_Notify *notify, + Efl_Selection_Data *ddata, Tmp_Info **tmp_info EINA_UNUSED) +{ + sel_debug("markup data preparer"); + Ecore_X_Selection_Data *data = notify->data; + ddata->format = EFL_SELECTION_FORMAT_MARKUP; + ddata->data.mem = eina_memdup(data->data, data->length, EINA_TRUE); + ddata->data.len = data->length; + return EINA_TRUE; +} + +/** + * So someone is pasting an image into my entry or widget... + */ +static Eina_Bool +_x11_data_preparer_uri(Sel_Manager_Seat_Selection *seat_sel, Ecore_X_Event_Selection_Notify *notify, + Efl_Selection_Data *ddata, Tmp_Info **tmp_info EINA_UNUSED) +{ + sel_debug("uri data preparer"); + Ecore_X_Selection_Data *data; + Ecore_X_Selection_Data_Files *files; + char *p, *stripstr = NULL; + + data = notify->data; + sel_debug("data->format is %d %p %p\n", data->format, notify, data); + if (data->content == ECORE_X_SELECTION_CONTENT_FILES) + { + Efreet_Uri *uri; + Eina_Strbuf *strbuf; + int i; + + sel_debug("got a files list\n"); + files = notify->data; + /* + if (files->num_files > 1) + { + // Don't handle many items <- this makes mr bigglesworth sad :( + sel_debug("more then one file: Bailing\n"); + return EINA_FALSE; + } + stripstr = p = strdup(files->files[0]); + */ + + strbuf = eina_strbuf_new(); + if (!strbuf) + return EINA_FALSE; + + for (i = 0; i < files->num_files ; i++) + { + uri = efreet_uri_decode(files->files[i]); + if (uri) + { + eina_strbuf_append(strbuf, uri->path); + efreet_uri_free(uri); + } + else + { + eina_strbuf_append(strbuf, files->files[i]); + } + if (i < (files->num_files - 1)) + eina_strbuf_append(strbuf, "\n"); + } + stripstr = eina_strbuf_string_steal(strbuf); + eina_strbuf_free(strbuf); + } + else + { + Efreet_Uri *uri; + + p = (char *)eina_memdup((unsigned char *)data->data, data->length, EINA_TRUE); + if (!p) return EINA_FALSE; + uri = efreet_uri_decode(p); + if (!uri) + { + /* Is there any reason why we care of URI without scheme? */ + if (p[0] == '/') stripstr = p; + else free(p); + } + else + { + free(p); + stripstr = strdup(uri->path); + efreet_uri_free(uri); + } + } + + if (!stripstr) + { + sel_debug("Couldn't find a file\n"); + return EINA_FALSE; + } + free(seat_sel->saved_types->imgfile); + if (seat_sel->saved_types->textreq) + { + seat_sel->saved_types->textreq = 0; + seat_sel->saved_types->imgfile = stripstr; + } + else + { + ddata->format = EFL_SELECTION_FORMAT_IMAGE; + ddata->data.mem = stripstr; + ddata->data.len = strlen(stripstr); + seat_sel->saved_types->imgfile = NULL; + } + return EINA_TRUE; +} + +/** + * Just received an vcard, either through cut and paste, or dnd. + */ +static Eina_Bool +_x11_data_preparer_vcard(Sel_Manager_Seat_Selection *seat_sel EINA_UNUSED, + Ecore_X_Event_Selection_Notify *notify, + Efl_Selection_Data *ddata, Tmp_Info **tmp_info EINA_UNUSED) +{ + sel_debug("vcard receive\n"); + Ecore_X_Selection_Data *data = notify->data; + ddata->format = EFL_SELECTION_FORMAT_VCARD; + ddata->data.mem = eina_memdup(data->data, data->length, EINA_TRUE); + ddata->data.len = data->length; + return EINA_TRUE; +} + +static Eina_Bool +_x11_data_preparer_image(Sel_Manager_Seat_Selection *seat_sel EINA_UNUSED, + Ecore_X_Event_Selection_Notify *notify, + Efl_Selection_Data *ddata, Tmp_Info **tmp_info) +{ + Ecore_X_Selection_Data *data = notify->data; + sel_debug("got a image file!\n"); + sel_debug("Size if %d\n", data->length); + + ddata->format = EFL_SELECTION_FORMAT_IMAGE; + data = notify->data; + + Tmp_Info *tmp = _tempfile_new(data->length); + if (!tmp) return EINA_FALSE; + memcpy(tmp->map, data->data, data->length); + munmap(tmp->map, data->length); + ddata->data.mem = strdup(tmp->filename); + ddata->data.len = strlen(tmp->filename); + *tmp_info = tmp; + return EINA_TRUE; +} + +/* + * Callback to handle a targets response on a selection request: + * So pick the format we'd like; and then request it. + */ +static Eina_Bool +_x11_notify_handler_targets(Efl_Selection_Manager_Data *pd, Sel_Manager_Selection *sel, Ecore_X_Event_Selection_Notify *notify) +{ + sel_debug("notify handler targets"); + Ecore_X_Selection_Data_Targets *targets; + Ecore_X_Atom *atom_list; + int i, j; + + targets = notify->data; + atom_list = (Ecore_X_Atom *)(targets->data.data); + for (j = (SELECTION_ATOM_LISTING_ATOMS + 1); j < SELECTION_N_ATOMS; j++) + { + sel_debug("\t%s %d", pd->atom_list[j].name, pd->atom_list[j].x_atom); + if (!(pd->atom_list[j].format & sel->request_format)) continue; + for (i = 0; i < targets->data.length; i++) + { + if ((pd->atom_list[j].x_atom == atom_list[i]) && (pd->atom_list[j].x_data_preparer)) + { + if (j == SELECTION_ATOM_TEXT_URILIST) + { + if (!_x11_is_uri_type_data(sel, notify)) continue; + } + sel_debug("Atom %s matches", pd->atom_list[j].name); + goto done; + } + } + } + sel_debug("Couldn't find anything that matches"); + return ECORE_CALLBACK_PASS_ON; +done: + sel_debug("Sending request for %s, xwin=%#llx", + pd->atom_list[j].name, (unsigned long long)sel->xwin); + sel->request(sel->xwin, pd->atom_list[j].name); + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_x11_fixes_selection_notify(void *data, int t EINA_UNUSED, void *event) +{ + Efl_Selection_Manager_Data *pd = data; + Efl_Selection_Changed e; + Ecore_X_Event_Fixes_Selection_Notify *ev = event; + Sel_Manager_Seat_Selection *seat_sel; + Efl_Selection_Type type; + Sel_Manager_Selection *sel; + + switch (ev->selection) + { + case ECORE_X_SELECTION_CLIPBOARD: + type = EFL_SELECTION_TYPE_CLIPBOARD; + break; + case ECORE_X_SELECTION_PRIMARY: + type = EFL_SELECTION_TYPE_PRIMARY; + break; + default: return ECORE_CALLBACK_RENEW; + } + seat_sel = _x11_sel_manager_seat_selection_init(pd, 1); + if (!seat_sel) return ECORE_CALLBACK_RENEW; + sel = seat_sel->sel_list + type; + if (sel->active && (sel->xwin != ev->owner)) + efl_selection_manager_selection_clear(pd->sel_man, sel->owner, type, seat_sel->seat); + e.type = type; + e.seat = 1; /* under x11 this is always the default seat */ + e.exist = !!ev->owner; + //efl_event_callback_call(sel->owner, EFL_SELECTION_EVENT_SELECTION_CHANGED, &e); + //ecore_event_add(ELM_CNP_EVENT_SELECTION_CHANGED, e, NULL, NULL); + + return ECORE_CALLBACK_RENEW; +} + +/* + * Response to a selection notify: + * - So we have asked for the selection list. + * - If it's the targets list, parse it, and fire of what we want, + * else it's the data we want. + */ +//NB: x11 does not have seat, use 1 as default +static Eina_Bool +_efl_sel_manager_x11_selection_notify(void *udata, int type EINA_UNUSED, void *event) +{ + Efl_Selection_Manager_Data *pd = udata; + Ecore_X_Event_Selection_Notify *ev = event; + Sel_Manager_Selection *sel; + Sel_Manager_Seat_Selection *seat_sel = NULL; + int i; + + seat_sel = _sel_manager_seat_selection_get(pd, 1); + if (!seat_sel) + return EINA_FALSE; + + sel_debug("selection notify callback: %d", ev->selection); + switch (ev->selection) + { + case ECORE_X_SELECTION_PRIMARY: + sel = seat_sel->sel_list + EFL_SELECTION_TYPE_PRIMARY; + break; + case ECORE_X_SELECTION_SECONDARY: + sel = seat_sel->sel_list + EFL_SELECTION_TYPE_SECONDARY; + break; + case ECORE_X_SELECTION_XDND: + sel = seat_sel->sel_list + EFL_SELECTION_TYPE_DND; + break; + case ECORE_X_SELECTION_CLIPBOARD: + sel = seat_sel->sel_list + EFL_SELECTION_TYPE_CLIPBOARD; + break; + default: + return ECORE_CALLBACK_PASS_ON; + } + sel_debug("Target is %s", ev->target); + + if (ev->selection != ECORE_X_SELECTION_XDND && + (!strcmp(ev->target, "TARGETS") || !strcmp(ev->target, "ATOMS"))) + { + _x11_notify_handler_targets(pd, sel, ev); + return ECORE_CALLBACK_PASS_ON; + } + for (i = 0; i < SELECTION_N_ATOMS; i++) + { + if (!strcmp(ev->target, pd->atom_list[i].name)) + { + if (pd->atom_list[i].x_data_preparer) + { + Efl_Selection_Data ddata; + Tmp_Info *tmp_info = NULL; + Eina_Bool success; + sel_debug("Found something: %s", pd->atom_list[i].name); + + success = pd->atom_list[i].x_data_preparer(seat_sel, ev, &ddata, &tmp_info); + sel_debug("ddata: %s (%zd)", (const char *)ddata.data.mem, ddata.data.len); + if ((pd->atom_list[i].format == EFL_SELECTION_FORMAT_IMAGE) && + (seat_sel->saved_types->imgfile)) + break; + if (ev->selection == ECORE_X_SELECTION_XDND) + { + if (success) + { + Sel_Manager_Dropable *dropable; + Eina_List *l; + sel_debug("drag & drop\n"); + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + { + if (dropable->obj == sel->request_obj) break; + dropable = NULL; + } + if (dropable) + { + Drop_Format *df; + Eina_Inlist *itr; + + ddata.action = sel->action; + if (!dropable->is_container) + { + sel_debug("normal dnd, not container"); + ddata.pos = seat_sel->saved_types->pos; + } + else + { + sel_debug("Drop on container"); + Eina_Position2D pos, posret; + evas_object_geometry_get(dropable->obj, &pos.x, &pos.y, NULL, NULL); + //get item + pos = EINA_POSITION2D(seat_sel->saved_types->pos.x + pos.x, + seat_sel->saved_types->pos.y + pos.y); + Efl_Object *it = NULL; + if (dropable->item_func) + it = dropable->item_func(dropable->item_func_data, + dropable->obj, pos, &posret); + ddata.pos = posret; + ddata.item = it; + } + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + if (df->format & dropable->last.format) + { + sel_debug("calling Drop event on: %p", dropable->obj); + //efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_DROP, &ddata); + } + } + } + else + { + sel_debug("dnd: has NO dropable"); + } + } + /* We have to finish DnD, no matter what */ + ecore_x_dnd_send_finished(); + } + else if (sel->data_func && success) + { + ddata.pos.x = ddata.pos.y = 0; + sel->data_func(sel->data_func_data, sel->request_obj, &ddata); + } + free((void *)ddata.data.mem); + if (tmp_info) _tmpinfo_free(tmp_info); + } + else sel_debug("Ignored: No handler!"); + break; + } + } + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_x11_selection_clear(void *data, int type EINA_UNUSED, void *event) +{ + Efl_Selection_Manager_Data *pd = data; + Ecore_X_Event_Selection_Clear *ev = event; + Sel_Manager_Selection *sel; + Sel_Manager_Seat_Selection *seat_sel = NULL; + Eina_List *l, *l_next; + Sel_Manager_Selection_Lost *sel_lost; + unsigned int i; + ERR("In"); + + seat_sel = _sel_manager_seat_selection_get(pd, 1); + if (!seat_sel) + return EINA_FALSE; + + for (i = EFL_SELECTION_TYPE_PRIMARY; i <= EFL_SELECTION_TYPE_CLIPBOARD; i++) + { + if (seat_sel->sel_list[i].ecore_sel == ev->selection) break; + } + sel_debug("selection %d clear", i); + /* Not me... Don't care */ + if (i > EFL_SELECTION_TYPE_CLIPBOARD) return ECORE_CALLBACK_PASS_ON; + + sel = seat_sel->sel_list + i; + + EINA_LIST_FOREACH_SAFE(seat_sel->sel_lost_list, l, l_next, sel_lost) + { + if ((sel_lost->request == sel->owner) && + (sel_lost->type == i)) + { + sel_debug("resolve the promise: %p", sel_lost->promise); + eina_promise_resolve(sel_lost->promise, eina_value_uint_init(sel_lost->type)); + seat_sel->sel_lost_list = eina_list_remove(seat_sel->sel_lost_list, sel_lost); + free(sel_lost); + } + } + sel->active = EINA_FALSE; + sel->owner = NULL; + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_x11_general_converter(char *target EINA_UNUSED, void *data, int size EINA_UNUSED, void **data_ret, int *size_ret, Ecore_X_Atom *ttype EINA_UNUSED, int *typesize EINA_UNUSED) +{ + sel_debug("general converter"); + Sel_Manager_Selection *sel = *(Sel_Manager_Selection **)data; + if (sel->format == EFL_SELECTION_FORMAT_NONE) + { + if (data_ret) + { + *data_ret = malloc(sel->data.len * sizeof(char) + 1); + if (!*data_ret) return EINA_FALSE; + memcpy(*data_ret, sel->data.mem, sel->data.len); + ((char**)(data_ret))[0][sel->data.len] = 0; + } + if (size_ret) *size_ret = sel->data.len; + } + else + { + if (sel->data.mem) + { + if (data_ret) + { + *data_ret = strdup(sel->data.mem); + ((char **)(data_ret))[0][sel->data.len] = 0; + } + if (size_ret) *size_ret = strlen(sel->data.mem); + } + else + { + if (data_ret) *data_ret = NULL; + if (size_ret) *size_ret = 0; + } + } + return EINA_TRUE; +} + +static Eina_Bool +_x11_targets_converter(char *target EINA_UNUSED, void *data, int size EINA_UNUSED, void **data_ret, int *size_ret, Ecore_X_Atom *ttype, int *typesize) +{ + int i, count; + Ecore_X_Atom *aret; + Sel_Manager_Selection *sel; + Efl_Selection_Format seltype; + + sel_debug("target converter"); + if (!data_ret) return EINA_FALSE; + + sel = *(Sel_Manager_Selection **)data; + seltype = sel->format; + Sel_Manager_Seat_Selection *seat_sel = sel->seat_sel; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + + for (i = SELECTION_ATOM_LISTING_ATOMS + 1, count = 0; i < SELECTION_N_ATOMS ; i++) + { + if (seltype & pd->atom_list[i].format) count++; + } + aret = malloc(sizeof(Ecore_X_Atom) * count); + if (!aret) return EINA_FALSE; + for (i = SELECTION_ATOM_LISTING_ATOMS + 1, count = 0; i < SELECTION_N_ATOMS ; i++) + { + if (seltype & pd->atom_list[i].format) + aret[count ++] = pd->atom_list[i].x_atom; + } + + *data_ret = aret; + if (typesize) *typesize = 32 /* urk */; + if (ttype) *ttype = ECORE_X_ATOM_ATOM; + if (size_ret) *size_ret = count; + return EINA_TRUE; +} + +static Eina_Bool +_x11_image_converter(char *target EINA_UNUSED, void *data EINA_UNUSED, int size EINA_UNUSED, void **data_ret EINA_UNUSED, int *size_ret EINA_UNUSED, Ecore_X_Atom *ttype EINA_UNUSED, int *typesize EINA_UNUSED) +{ + sel_debug("Image converter called"); + return EINA_TRUE; +} + +static Eina_Bool +_x11_vcard_send(char *target EINA_UNUSED, void *data EINA_UNUSED, int size EINA_UNUSED, void **data_ret, int *size_ret, Ecore_X_Atom *ttype EINA_UNUSED, int *typesize EINA_UNUSED) +{ + Sel_Manager_Selection *sel; + + sel_debug("Vcard send called"); + sel = *(Sel_Manager_Selection **)data; + if (data_ret) *data_ret = strdup(sel->data.mem); + if (size_ret) *size_ret = strlen(sel->data.mem); + return EINA_TRUE; +} + +static Eina_Bool +_x11_text_converter(char *target, void *data, int size EINA_UNUSED, void **data_ret, int *size_ret, Ecore_X_Atom *ttype, int *typesize) +{ + Sel_Manager_Selection *sel; + + sel = *(Sel_Manager_Selection **)data; + if (!sel) return EINA_FALSE; + + sel_debug("text converter"); + if (sel->format == EFL_SELECTION_FORMAT_NONE) + { + sel_debug("none"); + if (data_ret) + { + *data_ret = malloc(sel->data.len * sizeof(char) + 1); + if (!*data_ret) return EINA_FALSE; + memcpy(*data_ret, data, sel->data.len); + ((char**)(data_ret))[0][sel->data.len] = 0; + } + if (size_ret) *size_ret = sel->data.len; + return EINA_TRUE; + } + + if (!sel->active) return EINA_TRUE; + + if ((sel->format & EFL_SELECTION_FORMAT_MARKUP) || + (sel->format & EFL_SELECTION_FORMAT_HTML)) + { + *data_ret = _elm_util_mkup_to_text(sel->data.mem); + if (size_ret && *data_ret) *size_ret = strlen(*data_ret); + sel_debug("markup or html: %s", (const char *)*data_ret); + } + else if (sel->format & EFL_SELECTION_FORMAT_TEXT) + { + ecore_x_selection_converter_text(target, sel->data.mem, + sel->data.len, + data_ret, size_ret, + ttype, typesize); + sel_debug("text"); + } + else if (sel->format & EFL_SELECTION_FORMAT_IMAGE) + { + efl_file_get(sel->request_obj, (const char **)data_ret, NULL); + if (!*data_ret) *data_ret = strdup("No file"); + else *data_ret = strdup(*data_ret); + + if (!*data_ret) + { + ERR("Failed to allocate memory!"); + *size_ret = 0; + return EINA_FALSE; + } + + *size_ret = strlen(*data_ret); + } + return EINA_TRUE; +} + +static void +_sel_manager_promise_cancel(void *data, const Eina_Promise *dead_future EINA_UNUSED) +{ + Sel_Manager_Selection_Lost *sel_lost = data; + //FIXME: remove from sel_lost_list in seat_sel + free(sel_lost); +} + +static inline Eina_Future * +_update_sel_lost_list(Efl_Object *obj, Efl_Selection_Type type, + Sel_Manager_Seat_Selection *seat_sel) +{ + Eina_Promise *p; + Sel_Manager_Selection_Lost *sel_lost; + + sel_lost = calloc(1, sizeof(Sel_Manager_Selection_Lost)); + if (!sel_lost) + return NULL; + sel_lost->request = obj; + sel_lost->type = type; + seat_sel->sel_lost_list = eina_list_append(seat_sel->sel_lost_list, sel_lost); + + p = eina_promise_new(efl_loop_future_scheduler_get(obj), + _sel_manager_promise_cancel, NULL); + eina_promise_data_set(p, sel_lost); + if (!p) return NULL; + sel_lost->promise = p; + + return eina_future_new(p); +} + +static Eina_Future * +_x11_efl_sel_manager_selection_set(Efl_Selection_Manager_Data *pd, Efl_Object *owner, + Efl_Selection_Type type, Efl_Selection_Format format, Eina_Slice data, + Ecore_X_Window xwin, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + Eina_Bool same_win = EINA_FALSE; + + seat_sel = _x11_sel_manager_seat_selection_init(pd, seat); + seat_sel->active_type = type; + sel = seat_sel->sel_list + type; + //support 1 app with multiple window, 1 selection manager + if (sel->xwin == xwin) + same_win = EINA_TRUE; + _owner_change_check(owner, seat_sel, sel, type, same_win); + + sel->owner = owner; + free(sel->data.mem); + sel->xwin = xwin; + sel->data = eina_slice_dup(data); + sel->active = EINA_TRUE; + sel->format = format; + + sel->set(xwin, &sel, sizeof(&sel)); + sel_debug("data: %p (%ld)", &sel, sizeof(&sel)); + + return _update_sel_lost_list(owner, type, seat_sel); +} + +static void +_x11_efl_sel_manager_selection_get(const Efl_Object *request, Efl_Selection_Manager_Data *pd, + Efl_Selection_Type type, Efl_Selection_Format format, + void *data_func_data, Efl_Selection_Data_Ready data_func, Eina_Free_Cb data_func_free_cb, + Ecore_X_Window xwin, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel;; + + sel_debug("request: %p, seat: %u, type: %d, format: %d", request, seat, type, format); + seat_sel = _sel_manager_seat_selection_init(pd, seat); + sel = seat_sel->sel_list + type; + sel->request_obj = (Efl_Object *)request; + sel->data_func_data = data_func_data; + sel->data_func = data_func; + sel->data_func_free_cb = data_func_free_cb; + sel->request_format = format; + sel->xwin = xwin; + + if (sel->active) + { + if (sel->data.mem && + ((format == sel->format) || (xwin == 0))) + { + sel_debug("use local data"); + Efl_Selection_Data seldata; + + seldata.data.mem = sel->data.mem; + seldata.data.len = sel->data.len; + seldata.pos.x = seldata.pos.y = 0; + seldata.format = sel->format; + sel->data_func(sel->data_func_data, sel->request_obj, &seldata); + return; + } + } + + sel->request(xwin, ECORE_X_SELECTION_TARGET_TARGETS); +} + +static void +_x11_win_rotation_changed_cb(void *data, const Efl_Event *event) +{ + Evas_Object *win = data; + int rot = elm_win_rotation_get(event->object); + elm_win_rotation_set(win, rot); +} + +static Eina_Bool +_x11_drag_mouse_up(void *data, int etype EINA_UNUSED, void *event) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + Ecore_X_Window xwin = seat_sel->xwin; + Ecore_Event_Mouse_Button *ev = event; + + if ((ev->buttons == 1) && + (ev->event_window == xwin)) + { + Eina_Bool have_drop_list = EINA_FALSE; + Eina_List *l; + Sel_Manager_Dropable *dropable; + + ecore_x_pointer_ungrab(); + ELM_SAFE_FREE(seat_sel->mouse_up_handler, ecore_event_handler_del); + ELM_SAFE_FREE(seat_sel->dnd_status_handler, ecore_event_handler_del); + ecore_x_dnd_self_drop(); + + sel_debug("mouse up, xwin=%#llx\n", (unsigned long long)xwin); + + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + { + if (xwin == _x11_xwin_get(dropable->obj)) + { + have_drop_list = EINA_TRUE; + break; + } + } + if (!have_drop_list) ecore_x_dnd_aware_set(xwin, EINA_FALSE); + //efl_event_callback_call(seat_sel->drag_obj, EFL_UI_DND_EVENT_DRAG_DONE, NULL); + if (seat_sel->drag_win) + { + if (seat_sel->drag_obj) + { + if (elm_widget_is(seat_sel->drag_obj)) + { + Evas_Object *win = elm_widget_top_get(seat_sel->drag_obj); + if (win && efl_isa(win, EFL_UI_WIN_CLASS)) + efl_event_callback_del(win, EFL_UI_WIN_EVENT_ROTATION_CHANGED, + _x11_win_rotation_changed_cb, seat_sel->drag_win); + } + } + + if (!seat_sel->accept) + { /* Commit animation when drag cancelled */ + /* Record final position of dragwin, then do animation */ + ecore_animator_timeline_add(0.3, + _drag_cancel_animate, seat_sel); + } + else + { /* No animation drop was committed */ + Ecore_X_Window xdragwin = _x11_xwin_get(seat_sel->drag_win); + ecore_x_window_ignore_set(xdragwin, 0); + evas_object_del(seat_sel->drag_win); + seat_sel->drag_win = NULL; + sel_debug("deleted drag_win"); + } + } + + seat_sel->drag_obj = NULL; + seat_sel->accept = EINA_FALSE; + } + return EINA_TRUE; +} + +static void +_x11_drag_move(void *data, Ecore_X_Xdnd_Position *pos) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + Efl_Dnd_Drag_Pos dp; + + evas_object_move(seat_sel->drag_win, + pos->position.x - seat_sel->drag_pos.x, + pos->position.y - seat_sel->drag_pos.y); + seat_sel->drag_win_end.x = pos->position.x - seat_sel->drag_pos.x; + seat_sel->drag_win_end.y = pos->position.y - seat_sel->drag_pos.y; + sel_debug("dragevas: %p -> %p\n", + seat_sel->drag_obj, + evas_object_evas_get(seat_sel->drag_obj)); + dp.pos.x = pos->position.x; + dp.pos.y = pos->position.y; + dp.action = seat_sel->drag_action; + //for drag side + //efl_event_callback_call(seat_sel->drag_obj, EFL_UI_DND_EVENT_DRAG_POS, &dp); +} + +static void +_x11_drag_target_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *info EINA_UNUSED) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + Sel_Manager_Selection *sel = &seat_sel->sel_list[seat_sel->active_type]; + + if (seat_sel->drag_obj == obj) + { + sel->request_obj = NULL; + seat_sel->drag_obj = NULL; + } +} + +static Eina_Bool +_x11_dnd_status(void *data, int etype EINA_UNUSED, void *ev) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + Ecore_X_Event_Xdnd_Status *status = ev; + + seat_sel->accept = EINA_FALSE; + + /* Only thing we care about: will accept */ + if ((status) && (status->will_accept)) + { + sel_debug("Will accept\n"); + seat_sel->accept = EINA_TRUE; + } + /* Won't accept */ + else + { + sel_debug("Won't accept accept\n"); + } + //efl_event_callback_call(seat_sel->drag_obj, EFL_UI_DND_EVENT_DRAG_ACCEPT, &seat_sel->accept); + + return EINA_TRUE; +} + +static void +_x11_efl_sel_manager_drag_start(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *drag_obj, Efl_Selection_Format format, + Eina_Slice data, Efl_Selection_Action action, + void *icon_func_data, Efl_Dnd_Drag_Icon_Create icon_func, + Eina_Free_Cb icon_func_free_cb EINA_UNUSED, + Ecore_X_Window xwin, unsigned int seat) +{ + Ecore_X_Window xdragwin; + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + Ecore_Evas *ee; + int x, y, x2 = 0, y2 = 0, x3, y3; + Evas_Object *icon = NULL; + int w = 0, h = 0; + int ex, ey, ew, eh; + Ecore_X_Atom actx; + int i; + int xr, yr, rot; + + seat_sel = _x11_sel_manager_seat_selection_init(pd, seat); + if (!seat_sel) return; + seat_sel->active_type = EFL_SELECTION_TYPE_DND; + + sel = &seat_sel->sel_list[seat_sel->active_type]; + ecore_x_dnd_types_set(xwin, NULL, 0); + for (i = SELECTION_ATOM_LISTING_ATOMS + 1; i < SELECTION_N_ATOMS; i++) + { + if (format == EFL_SELECTION_FORMAT_TARGETS || (pd->atom_list[i].format & format)) + { + ecore_x_dnd_type_set(xwin, pd->atom_list[i].name, EINA_TRUE); + sel_debug("set dnd type: %s\n", pd->atom_list[i].name); + } + } + + sel->active = EINA_TRUE; + sel->request_obj = drag_obj; + sel->format = format; + if (sel->data.mem) free(sel->data.mem); + sel->data = eina_slice_dup(data); + sel->action = action; + seat_sel->drag_obj = drag_obj; + seat_sel->drag_action = action; + seat_sel->xwin = xwin; + + evas_object_event_callback_add(drag_obj, EVAS_CALLBACK_DEL, + _x11_drag_target_del, seat_sel); + /* TODO BUG: should increase dnd-awareness, in case it's drop target as well. See _x11_drag_mouse_up() */ + ecore_x_dnd_aware_set(xwin, EINA_TRUE); + ecore_x_dnd_callback_pos_update_set(_x11_drag_move, seat_sel); + ecore_x_dnd_self_begin(xwin, (unsigned char *)&sel, sizeof(Sel_Manager_Selection)); + actx = _x11_dnd_action_rev_map(seat_sel->drag_action); + ecore_x_dnd_source_action_set(actx); + ecore_x_pointer_grab(xwin); + seat_sel->mouse_up_handler = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, + _x11_drag_mouse_up, seat_sel); + seat_sel->dnd_status_handler = ecore_event_handler_add(ECORE_X_EVENT_XDND_STATUS, + _x11_dnd_status, seat_sel); + seat_sel->drag_win = elm_win_add(NULL, "Elm-Drag", ELM_WIN_DND); + elm_win_alpha_set(seat_sel->drag_win, EINA_TRUE); + elm_win_override_set(seat_sel->drag_win, EINA_TRUE); + xdragwin = _x11_xwin_get(seat_sel->drag_win); + ecore_x_window_ignore_set(xdragwin, 1); + + /* dragwin has to be rotated as the main window is */ + if (elm_widget_is(drag_obj)) + { + Evas_Object *win = elm_widget_top_get(drag_obj); + if (win && efl_isa(win, EFL_UI_WIN_CLASS)) + { + elm_win_rotation_set(seat_sel->drag_win, elm_win_rotation_get(win)); + efl_event_callback_add(win, EFL_UI_WIN_EVENT_ROTATION_CHANGED, + _x11_win_rotation_changed_cb, seat_sel->drag_win); + } + } + + if (icon_func) + { + Eina_Position2D off; + + icon = icon_func(icon_func_data, seat_sel->drag_win, drag_obj, &off); + if (icon) + { + x2 = off.x; + y2 = off.y; + evas_object_geometry_get(icon, NULL, NULL, &w, &h); + } + } + else + { + icon = elm_icon_add(seat_sel->drag_win); + evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + // need to resize + } + elm_win_resize_object_add(seat_sel->drag_win, icon); + + /* Position subwindow appropriately */ + ee = ecore_evas_ecore_evas_get(evas_object_evas_get(drag_obj)); + ecore_evas_geometry_get(ee, &ex, &ey, &ew, &eh); + evas_object_resize(seat_sel->drag_win, w, h); + + evas_object_show(icon); + evas_object_show(seat_sel->drag_win); + evas_pointer_canvas_xy_get(evas_object_evas_get(drag_obj), &x3, &y3); + + rot = ecore_evas_rotation_get(ee); + switch (rot) + { + case 90: + xr = y3; + yr = ew - x3; + seat_sel->drag_pos.x = y3 - y2; + seat_sel->drag_pos.y = x3 - x2; + break; + case 180: + xr = ew - x3; + yr = eh - y3; + seat_sel->drag_pos.x = x3 - x2; + seat_sel->drag_pos.y = y3 - y2; + break; + case 270: + xr = eh - y3; + yr = x3; + seat_sel->drag_pos.x = y3 - y2; + seat_sel->drag_pos.y = x3 - x2; + break; + default: + xr = x3; + yr = y3; + seat_sel->drag_pos.x = x3 - x2; + seat_sel->drag_pos.y = y3 - y2; + break; + } + x = ex + xr - seat_sel->drag_pos.x; + y = ey + yr - seat_sel->drag_pos.y; + evas_object_move(seat_sel->drag_win, x, y); + seat_sel->drag_win_start = EINA_POSITION2D(x, y); + seat_sel->drag_win_end = EINA_POSITION2D(x, y); +} + +static void +_x11_dnd_dropable_handle(Efl_Selection_Manager_Data *pd, Sel_Manager_Dropable *dropable, Eina_Position2D pos, Efl_Selection_Action action) +{ + Sel_Manager_Dropable *d, *last_dropable = NULL; + Eina_List *l; + Eina_Inlist *itr; + + EINA_LIST_FOREACH(pd->drop_list, l, d) + { + if (d->last.in) + { + last_dropable = d; + break; + } + } + if (last_dropable) + { + if (last_dropable == dropable) // same + { + Evas_Coord ox, oy; + Drop_Format *df; + + sel_debug("same obj dropable %p\n", dropable->obj); + evas_object_geometry_get(dropable->obj, &ox, &oy, NULL, NULL); + Efl_Dnd_Drag_Pos pos_data; + if (!dropable->is_container) + { + pos_data.pos = EINA_POSITION2D(pos.x - ox, pos.y - oy); + pos_data.item = NULL; + } + else + { + Eina_Position2D posret; + Efl_Object *it = NULL; + + if (dropable->item_func) + it = dropable->item_func(dropable->item_func_data, dropable->obj, + pos, &posret); + pos_data.pos = posret; + pos_data.item = it; + } + pos_data.format = dropable->last.format; + pos_data.action = action; + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + if (df->format & dropable->last.format) + { + //efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_POS, &pos_data); + } + } + } + else + { + if (dropable) // leave last obj and enter new one + { + sel_debug("leave %p\n", last_dropable->obj); + sel_debug("enter %p\n", dropable->obj); + last_dropable->last.in = EINA_FALSE; + last_dropable->last.type = NULL; + dropable->last.in = EINA_TRUE; + + Drop_Format *df; + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + //if (df->format &dropable->last.format) + // efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_ENTER, NULL); + } + EINA_INLIST_FOREACH_SAFE(last_dropable->format_list, itr, df) + { + //if (df->format & last_dropable->last.format) + // efl_event_callback_call(last_dropable->obj, EFL_UI_DND_EVENT_DRAG_LEAVE, NULL); + } + } + else // leave last obj + { + sel_debug("leave %p\n", last_dropable->obj); + last_dropable->last.in = EINA_FALSE; + last_dropable->last.type = NULL; + + Drop_Format *df; + EINA_INLIST_FOREACH_SAFE(last_dropable->format_list, itr, df) + { + //if (df->format & last_dropable->last.format) + // efl_event_callback_call(last_dropable->obj, EFL_UI_DND_EVENT_DRAG_LEAVE, NULL); + } + } + } + } + else + { + if (dropable) // enter new obj + { + Evas_Coord ox, oy; + + sel_debug("enter %p\n", dropable->obj); + evas_object_geometry_get(dropable->obj, &ox, &oy, NULL, NULL); + dropable->last.in = EINA_TRUE; + + Drop_Format *df; + Efl_Dnd_Drag_Pos pos_data; + if (!dropable->is_container) + { + pos_data.pos = EINA_POSITION2D(pos.x - ox, pos.y - oy); + pos_data.item = NULL; + } + else + { + Eina_Position2D posret; + Efl_Object *it = NULL; + if (dropable->item_func) + it = dropable->item_func(dropable->item_func_data, dropable->obj, + pos, &posret); + pos_data.pos = posret; + pos_data.item = it; + } + pos_data.format = dropable->last.format; + pos_data.action = action; + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + if (df->format & dropable->last.format) + { + //efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_ENTER, NULL); + //efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_POS, &pos_data); + } + } + } + else + { + sel_debug("both dropable & last_dropable are null\n"); + } + } +} + +static Sel_Manager_Dropable * +_x11_dropable_find(Efl_Selection_Manager_Data *pd, Ecore_X_Window win) +{ + Eina_List *l; + Sel_Manager_Dropable *dropable; + + if (!pd->drop_list) return NULL; + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + { + if (_x11_xwin_get(dropable->obj) == win) return dropable; + } + return NULL; +} + +static Evas * +_x11_evas_get_from_xwin(Efl_Selection_Manager_Data *pd, Ecore_X_Window win) +{ + /* Find the Evas connected to the window */ + Sel_Manager_Dropable *dropable = _x11_dropable_find(pd, win); + return dropable ? evas_object_evas_get(dropable->obj) : NULL; +} + +static Efl_Selection_Action +_x11_dnd_action_map(Ecore_X_Atom action) +{ + Efl_Selection_Action act = EFL_SELECTION_ACTION_UNKNOWN; + + if (action == ECORE_X_ATOM_XDND_ACTION_COPY) + act = EFL_SELECTION_ACTION_COPY; + else if (action == ECORE_X_ATOM_XDND_ACTION_MOVE) + act = EFL_SELECTION_ACTION_MOVE; + else if (action == ECORE_X_ATOM_XDND_ACTION_PRIVATE) + act = EFL_SELECTION_ACTION_PRIVATE; + else if (action == ECORE_X_ATOM_XDND_ACTION_ASK) + act = EFL_SELECTION_ACTION_ASK; + else if (action == ECORE_X_ATOM_XDND_ACTION_LIST) + act = EFL_SELECTION_ACTION_LIST; + else if (action == ECORE_X_ATOM_XDND_ACTION_LINK) + act = EFL_SELECTION_ACTION_LINK; + else if (action == ECORE_X_ATOM_XDND_ACTION_DESCRIPTION) + act = EFL_SELECTION_ACTION_DESCRIPTION; + return act; +} + +static Ecore_X_Atom +_x11_dnd_action_rev_map(Efl_Selection_Action action) +{ + Ecore_X_Atom act = ECORE_X_ATOM_XDND_ACTION_MOVE; + + if (action == EFL_SELECTION_ACTION_COPY) + act = ECORE_X_ATOM_XDND_ACTION_COPY; + else if (action == EFL_SELECTION_ACTION_MOVE) + act = ECORE_X_ATOM_XDND_ACTION_MOVE; + else if (action == EFL_SELECTION_ACTION_PRIVATE) + act = ECORE_X_ATOM_XDND_ACTION_PRIVATE; + else if (action == EFL_SELECTION_ACTION_ASK) + act = ECORE_X_ATOM_XDND_ACTION_ASK; + else if (action == EFL_SELECTION_ACTION_LIST) + act = ECORE_X_ATOM_XDND_ACTION_LIST; + else if (action == EFL_SELECTION_ACTION_LINK) + act = ECORE_X_ATOM_XDND_ACTION_LINK; + else if (action == EFL_SELECTION_ACTION_DESCRIPTION) + act = ECORE_X_ATOM_XDND_ACTION_DESCRIPTION; + return act; +} + +static Eina_Bool +_x11_dnd_enter(void *data, int etype EINA_UNUSED, void *ev) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + Ecore_X_Event_Xdnd_Enter *enter = ev; + Sel_Manager_Dropable *dropable; + int i; + + sel_debug("In"); + if (!enter) return EINA_TRUE; + dropable = _x11_dropable_find(pd, enter->win); + if (dropable) + { + sel_debug("Enter %x\n", enter->win); + } + /* Skip it */ + sel_debug("enter types=%p (%d)\n", enter->types, enter->num_types); + if ((!enter->num_types) || (!enter->types)) return EINA_TRUE; + + sel_debug("Types\n"); + seat_sel->saved_types->ntypes = enter->num_types; + free(seat_sel->saved_types->types); + seat_sel->saved_types->types = malloc(sizeof(char *) * enter->num_types); + if (!seat_sel->saved_types->types) return EINA_FALSE; + + for (i = 0; i < enter->num_types; i++) + { + seat_sel->saved_types->types[i] = eina_stringshare_add(enter->types[i]); + sel_debug("Type is %s %p %p\n", enter->types[i], + seat_sel->saved_types->types[i], pd->text_uri); + if (seat_sel->saved_types->types[i] == pd->text_uri) + { + /* Request it, so we know what it is */ + sel_debug("Sending uri request\n"); + seat_sel->saved_types->textreq = 1; + ELM_SAFE_FREE(seat_sel->saved_types->imgfile, free); + ecore_x_selection_xdnd_request(enter->win, pd->text_uri); + } + } + + /* FIXME: Find an object and make it current */ + return EINA_TRUE; +} + +static Eina_Bool +_x11_dnd_position(void *data, int etype EINA_UNUSED, void *ev) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + Ecore_X_Event_Xdnd_Position *xpos = ev; + Ecore_X_Rectangle rect = { 0, 0, 0, 0 }; + Sel_Manager_Dropable *dropable; + Efl_Selection_Action act; + + sel_debug("In"); + /* Need to send a status back */ + /* FIXME: Should check I can drop here */ + /* FIXME: Should highlight widget */ + dropable = _x11_dropable_find(pd, xpos->win); + if (dropable) + { + Evas_Coord ox = 0, oy = 0; + Eina_Position2D pos; + + act = _x11_dnd_action_map(xpos->action); + pos.x = xpos->position.x; + pos.y = xpos->position.y; + _dropable_coords_adjust(dropable, &pos); + Evas *evas = _x11_evas_get_from_xwin(pd, xpos->win); + Eina_List *dropable_list = evas ? _dropable_list_geom_find(pd, evas, pos.x, pos.y) : NULL; + /* check if there is dropable (obj) can accept this drop */ + if (dropable_list) + { + Efl_Selection_Format saved_format = _dnd_types_to_format(pd, seat_sel->saved_types->types, seat_sel->saved_types->ntypes); + Eina_List *l; + Eina_Bool found = EINA_FALSE; + + EINA_LIST_FOREACH(dropable_list, l, dropable) + { + Drop_Format *df; + Eina_Inlist *itr; + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + Efl_Selection_Format common_fmt = saved_format & df->format; + if (common_fmt) + { + //We found a target that can accept this type of data + int i, min_index = SELECTION_N_ATOMS; + //We have to find the first atom that corresponds to one + //of the supported data types. + for (i = 0; i < seat_sel->saved_types->ntypes; i++) + { + Sel_Manager_Atom *atom = eina_hash_find(pd->type_hash, seat_sel->saved_types->types[i]); + if (atom && (atom->format & common_fmt)) + { + int atom_idx = (atom - pd->atom_list); + if (min_index > atom_idx) min_index = atom_idx; + } + } + if (min_index != SELECTION_N_ATOMS) + { + sel_debug("Found atom %s\n", pd->atom_list[min_index].name); + found = EINA_TRUE; + dropable->last.type = pd->atom_list[min_index].name; + dropable->last.format = common_fmt; + break; + } + } + } + if (found) break; + } + if (found) + { + Sel_Manager_Dropable *d = NULL; + Eina_Rectangle inter_rect = {0, 0, 0, 0}; + int idx = 0; + EINA_LIST_FOREACH(dropable_list, l, d) + { + if (idx == 0) + { + evas_object_geometry_get(d->obj, &inter_rect.x, &inter_rect.y, + &inter_rect.w, &inter_rect.h); + } + else + { + Eina_Rectangle cur_rect; + evas_object_geometry_get(d->obj, &cur_rect.x, &cur_rect.y, + &cur_rect.w, &cur_rect.h); + if (!eina_rectangle_intersection(&inter_rect, &cur_rect)) continue; + } + idx++; + } + rect.x = inter_rect.x; + rect.y = inter_rect.y; + rect.width = inter_rect.w; + rect.height = inter_rect.h; + ecore_x_dnd_send_status(EINA_TRUE, EINA_FALSE, rect, xpos->action); + sel_debug("dnd position %i %i %p\n", pos.x - ox, pos.y - oy, dropable); + pos.x = pos.x - ox; + pos.y = pos.y - oy; + _x11_dnd_dropable_handle(pd, dropable, pos, act); + // CCCCCCC: call dnd exit on last obj if obj != last + // CCCCCCC: call drop position on obj + } + else + { + //if not: send false status + ecore_x_dnd_send_status(EINA_FALSE, EINA_FALSE, rect, xpos->action); + sel_debug("dnd position (%d, %d) not in obj\n", pos.x, pos.y); + _x11_dnd_dropable_handle(pd, NULL, EINA_POSITION2D(0, 0), act); + // CCCCCCC: call dnd exit on last obj + } + eina_list_free(dropable_list); + } + else + { + ecore_x_dnd_send_status(EINA_FALSE, EINA_FALSE, rect, xpos->action); + sel_debug("dnd position (%d, %d) has no drop\n", pos.x, pos.y); + _x11_dnd_dropable_handle(pd, NULL, EINA_POSITION2D(0, 0), act); + } + } + else + { + ecore_x_dnd_send_status(EINA_FALSE, EINA_FALSE, rect, xpos->action); + } + return EINA_TRUE; +} + +static Eina_Bool +_x11_dnd_leave(void *data, int etype EINA_UNUSED, void *ev) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + Eina_Position2D pos = {0, 0}; +#ifdef DEBUGON + sel_debug("Leave %x\n", ((Ecore_X_Event_Xdnd_Leave *)ev)->win); +#else + (void)ev; +#endif + _x11_dnd_dropable_handle(seat_sel->pd, NULL, pos, EFL_SELECTION_ACTION_UNKNOWN); + // CCCCCCC: call dnd exit on last obj if there was one + // leave->win leave->source + return EINA_TRUE; +} + +static Eina_Bool +_x11_dnd_drop(void *data, int etype EINA_UNUSED, void *ev) +{ + sel_debug("In"); + Sel_Manager_Seat_Selection *seat_sel = data; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + Ecore_X_Event_Xdnd_Drop *drop; + Sel_Manager_Dropable *dropable = NULL; + Efl_Selection_Data ddata; + Evas_Coord x = 0, y = 0; + Efl_Selection_Action act = EFL_SELECTION_ACTION_UNKNOWN; + Eina_List *l; + Eina_Inlist *itr; + Sel_Manager_Selection *sel; + + drop = ev; + sel_debug("drop_list %p (%d)\n", pd->drop_list, eina_list_count(pd->drop_list)); + if (!(dropable = _x11_dropable_find(pd, drop->win))) return EINA_TRUE; + + /* Calculate real (widget relative) position */ + // - window position + // - widget position + seat_sel->saved_types->pos = EINA_POSITION2D(drop->position.x, drop->position.y); + _dropable_coords_adjust(dropable, &seat_sel->saved_types->pos); + + sel_debug("Drop position is %d,%d\n", seat_sel->saved_types->pos.x, seat_sel->saved_types->pos.y); + + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + { + if (dropable->last.in) + { + evas_object_geometry_get(dropable->obj, &x, &y, NULL, NULL); + seat_sel->saved_types->pos.x -= x; + seat_sel->saved_types->pos.y -= y; + goto found; + } + } + + sel_debug("Didn't find a target\n"); + return EINA_TRUE; + +found: + sel_debug("0x%x\n", drop->win); + + act = _x11_dnd_action_map(drop->action); + + dropable->last.in = EINA_FALSE; + sel_debug("Last type: %s - Last format: %X\n", dropable->last.type, dropable->last.format); + if ((!strcmp(dropable->last.type, pd->text_uri))) + { + sel_debug("We found a URI... (%scached) %s\n", + seat_sel->saved_types->imgfile ? "" : "not ", + seat_sel->saved_types->imgfile); + if (seat_sel->saved_types->imgfile) + { + Drop_Format *df; + + if (!dropable->is_container) + { + ddata.pos = seat_sel->saved_types->pos; + ddata.item = NULL; + } + else + { + //for container + Efl_Object *it = NULL; + Evas_Coord x0 = 0, y0 = 0; + Eina_Position2D pos, posret; + + evas_object_geometry_get(dropable->obj, &x0, &y0, NULL, NULL); + pos = EINA_POSITION2D(seat_sel->saved_types->pos.x + x0, + seat_sel->saved_types->pos.y + y0); + if (dropable->item_func) + it = dropable->item_func(dropable->item_func_data, dropable->obj, + pos, &posret); + ddata.pos = posret; + ddata.item = it; + } + ddata.action = act; + + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + if (df->format & EFL_SELECTION_FORMAT_IMAGE) + { + sel_debug("Doing image insert (%s)\n", seat_sel->saved_types->imgfile); + ddata.format = EFL_SELECTION_FORMAT_IMAGE; + ddata.data.mem = (char *)seat_sel->saved_types->imgfile; + ddata.data.len = strlen(ddata.data.mem); + //if (df->format & dropable->last.format) + // efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_DROP, &ddata); + } + else + { + sel_debug("Item doesn't support images... passing\n"); + } + } + ecore_x_dnd_send_finished(); + ELM_SAFE_FREE(seat_sel->saved_types->imgfile, free); + return EINA_TRUE; + } + else if (seat_sel->saved_types->textreq) + { + /* Already asked: Pretend we asked now, and paste immediately when + * it comes in */ + seat_sel->saved_types->textreq = 0; + ecore_x_dnd_send_finished(); + return EINA_TRUE; + } + } + + sel = seat_sel->sel_list + EFL_SELECTION_TYPE_DND; + sel_debug("doing a request then: %s\n", dropable->last.type); + sel->xwin = drop->win; + sel->request_obj = dropable->obj; + sel->request_format = dropable->last.format; + sel->active = EINA_TRUE; + sel->action = act; + ecore_x_selection_xdnd_request(drop->win, dropable->last.type); + + return EINA_TRUE; +} + +static Eina_Bool +_x11_sel_manager_drop_target_add(Efl_Selection_Manager_Data *pd, Efl_Object *target_obj, + Efl_Selection_Format format, Ecore_X_Window xwin, + unsigned int seat) +{ + ERR("In"); + Sel_Manager_Dropable *dropable = NULL; + Eina_List *l; + Eina_Bool have_drop_list = EINA_FALSE; + Sel_Manager_Seat_Selection *seat_sel = NULL; + + /* Is this the first? */ + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + { + if (xwin == _x11_xwin_get(dropable->obj)) + { + have_drop_list = EINA_TRUE; + break; + } + } + dropable = NULL; // In case of error, we don't want to free it + + + Drop_Format *df = calloc(1, sizeof(Drop_Format)); + if (!df) return EINA_FALSE; + df->format = format; + + dropable = efl_key_data_get(target_obj, "__elm_dropable"); + if (!dropable) + { + /* Create new drop */ + dropable = calloc(1, sizeof(Sel_Manager_Dropable)); + if (!dropable) goto error; + dropable->last.in = EINA_FALSE; + pd->drop_list = eina_list_append(pd->drop_list, dropable); + if (!pd->drop_list) goto error; + dropable->obj = target_obj; + efl_key_data_set(target_obj, "__elm_dropable", dropable); + } + dropable->format_list = eina_inlist_append(dropable->format_list, EINA_INLIST_GET(df)); + dropable->seat = seat; + + evas_object_event_callback_add(target_obj, EVAS_CALLBACK_DEL, + _all_drop_targets_cbs_del, pd); + if (!have_drop_list) ecore_x_dnd_aware_set(xwin, EINA_TRUE); + + seat_sel = _x11_sel_manager_seat_selection_init(pd, seat); + + if (seat_sel->enter_handler) return EINA_TRUE; + sel_debug("Adding drop target calls xwin=%#llx", (unsigned long long)xwin); + seat_sel->enter_handler = ecore_event_handler_add(ECORE_X_EVENT_XDND_ENTER, + _x11_dnd_enter, seat_sel); + seat_sel->leave_handler = ecore_event_handler_add(ECORE_X_EVENT_XDND_LEAVE, + _x11_dnd_leave, seat_sel); + seat_sel->pos_handler = ecore_event_handler_add(ECORE_X_EVENT_XDND_POSITION, + _x11_dnd_position, seat_sel); + seat_sel->drop_handler = ecore_event_handler_add(ECORE_X_EVENT_XDND_DROP, + _x11_dnd_drop, seat_sel); + return EINA_TRUE; +error: + free(df); + free(dropable); + return EINA_FALSE; +} + +#endif + +//Wayland +#ifdef HAVE_ELEMENTARY_WL2 +static Sel_Manager_Seat_Selection * +_wl_sel_manager_seat_selection_init(Efl_Selection_Manager_Data *pd, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel = NULL; + Eina_List *l = NULL; + + EINA_LIST_FOREACH(pd->seat_list, l, seat_sel) + { + if(seat_sel->seat == seat) + break; + } + if (!seat_sel) + { + seat_sel = calloc(1, sizeof(Sel_Manager_Seat_Selection)); + if (!seat_sel) + { + ERR("Failed to allocate seat"); + return NULL; + } + seat_sel->saved_types = calloc(1, sizeof(Saved_Type)); + seat_sel->seat = seat; + seat_sel->pd = pd; + pd->seat_list = eina_list_append(pd->seat_list, seat_sel); + } + if (!seat_sel->sel) + { + Sel_Manager_Selection *sel = calloc(1, sizeof(Sel_Manager_Selection)); + if (!sel) + { + ERR("failed to allocate selection"); + return NULL; + } + sel->seat_sel = seat_sel; + seat_sel->sel = sel; + } + + return seat_sel; +} + +static void +_wl_drag_source_del(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj, void *event EINA_UNUSED) +{ + Sel_Manager_Seat_Selection *seat_sel = data; + if (seat_sel->drag_obj == obj) + seat_sel->drag_obj = NULL; +} + +static void +_wl_efl_sel_manager_drag_start(Eo *obj, Efl_Selection_Manager_Data *pd, Efl_Object *drag_obj, + Efl_Selection_Format format, Eina_Slice data, + Efl_Selection_Action action, void *icon_func_data, + Efl_Dnd_Drag_Icon_Create icon_func, Eina_Free_Cb icon_func_free_cb, + Ecore_Wl2_Window *win, unsigned int seat) +{ + Ecore_Evas *ee; + Evas_Object *icon = NULL; + int x, y, x2 = 0, y2 = 0, x3, y3, w = 0, h = 0; + const char *types[SELECTION_N_ATOMS + 1]; + int i, nb_types = 0; + Ecore_Wl2_Window *parent = NULL; + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + + sel_debug("In"); + seat_sel = _wl_sel_manager_seat_selection_init(pd, seat); + if (!seat_sel) return; + seat_sel->active_type = EFL_SELECTION_TYPE_DND; + sel = seat_sel->sel; + + sel_debug("checking drag_win: %p", seat_sel->drag_win); + /* if we already have a drag, get out */ + if (seat_sel->drag_win) return; + + for (i = SELECTION_ATOM_LISTING_ATOMS + 1; i < SELECTION_N_ATOMS; i++) + { + if (format == EFL_SELECTION_FORMAT_TARGETS || (pd->atom_list[i].format & format)) + { + types[nb_types++] = pd->atom_list[i].name; + sel_debug("set dnd type: %s\n", pd->atom_list[i].name); + } + } + types[nb_types] = NULL; + + ecore_wl2_dnd_drag_types_set(_wl_seat_get(win, drag_obj, seat), types); + + /* set the drag data used when a drop occurs */ + free(sel->data.mem); + sel->data.len = 0; + sel->data = eina_slice_dup(data); + + /* setup callback to notify if this object gets deleted */ + evas_object_event_callback_add(drag_obj, EVAS_CALLBACK_DEL, + _wl_drag_source_del, sel); + + seat_sel->drag_obj = drag_obj; + seat_sel->drag_action = action; + + seat_sel->drag_win = elm_win_add(NULL, "Elm-Drag", ELM_WIN_DND); + elm_win_alpha_set(seat_sel->drag_win, EINA_TRUE); + elm_win_borderless_set(seat_sel->drag_win, EINA_TRUE); + elm_win_override_set(seat_sel->drag_win, EINA_TRUE); + + win = elm_win_wl_window_get(seat_sel->drag_win); + + if (icon_func) + { + Eina_Position2D off; + + icon = icon_func(icon_func_data, seat_sel->drag_win, drag_obj, &off); + if (icon) + { + x2 = off.x; + y2 = off.y; + evas_object_geometry_get(icon, NULL, NULL, &w, &h); + } + } + else + { + icon = elm_icon_add(seat_sel->drag_win); + evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + } + + elm_win_resize_object_add(seat_sel->drag_win, icon); + evas_object_show(icon); + + /* Position subwindow appropriately */ + ee = ecore_evas_ecore_evas_get(evas_object_evas_get(drag_obj)); + ecore_evas_geometry_get(ee, &x, &y, NULL, NULL); + x += x2; + y += y2; + seat_sel->drag_win_start.x = seat_sel->drag_win_end.x = x; + seat_sel->drag_win_start.y = seat_sel->drag_win_end.y = y; + + evas_object_move(seat_sel->drag_win, x, y); + evas_object_resize(seat_sel->drag_win, w, h); + evas_object_show(seat_sel->drag_win); + + evas_pointer_canvas_xy_get(evas_object_evas_get(drag_obj), &x3, &y3); + seat_sel->drag_pos.x = x3 - x2; + seat_sel->drag_pos.y = y3 - y2; + + if (elm_widget_is(drag_obj)) + { + Evas_Object *top; + + top = elm_widget_top_get(drag_obj); + if (!top) top = elm_widget_top_get(elm_widget_parent_widget_get(drag_obj)); + if (top && (efl_isa(top, EFL_UI_WIN_CLASS))) + parent = elm_win_wl_window_get(top); + } + if (!parent) + { + Evas *evas; + + if (!(evas = evas_object_evas_get(drag_obj))) + return; + if (!(ee = ecore_evas_ecore_evas_get(evas))) + return; + + parent = ecore_evas_wayland2_window_get(ee); + } + + sel->drag_serial = ecore_wl2_dnd_drag_start(_wl_seat_get(win, drag_obj, seat), parent, win); +} + +static Eina_Bool +_wl_is_uri_type_data(const char *data, int len) +{ + char *p; + if (len < 6) return EINA_FALSE; + + p = (char *)data; + if (!p) return EINA_FALSE; + if (strncmp(p, "file:/", 6)) + { + if (*p != '/') return EINA_FALSE; + } + return EINA_TRUE; +} + +static Efl_Selection_Action +_wl_to_elm(Ecore_Wl2_Drag_Action action) +{ + #define CONV(wl, elm) if (action == wl) return elm; + CONV(ECORE_WL2_DRAG_ACTION_COPY, EFL_SELECTION_ACTION_COPY); + CONV(ECORE_WL2_DRAG_ACTION_MOVE, EFL_SELECTION_ACTION_MOVE); + CONV(ECORE_WL2_DRAG_ACTION_ASK, EFL_SELECTION_ACTION_ASK); + #undef CONV + return EFL_SELECTION_ACTION_UNKNOWN; +} + +static Eina_Bool +_wl_targets_converter(char *target, Sel_Manager_Selection *sel, void *data EINA_UNUSED, int size EINA_UNUSED, void **data_ret, int *size_ret) +{ + sel_debug("in\n"); + if (!data_ret) return EINA_FALSE; + + const char *sep = "\n"; + char *aret; + int len = 0; + int i = 0; + Sel_Manager_Seat_Selection *seat_sel = sel->seat_sel; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + Efl_Selection_Format format = EFL_SELECTION_FORMAT_NONE; + Eina_Bool is_uri = EINA_FALSE; + + if (sel->format) + { + format = sel->format; + is_uri = _wl_is_uri_type_data(sel->data.mem, sel->data.len); + } + else + { + Sel_Manager_Atom *atom = eina_hash_find(pd->type_hash, target); + if (atom) + format = atom->format; + } + for (i = 0; i < SELECTION_N_ATOMS; i++) + { + if (format & pd->atom_list[i].format) + { + if ((is_uri) || + ((!is_uri) && strcmp(pd->atom_list[i].name, "text/uri-list"))) + len += strlen(pd->atom_list[i].name) + strlen(sep); + } + } + len++; //terminating null byte + aret = calloc(1, len * sizeof(char)); + if (!aret) return EINA_FALSE; + for (i = 0; i < SELECTION_N_ATOMS; i++) + { + if (format & pd->atom_list[i].format) + { + if ((is_uri) || + ((!is_uri) && strcmp(pd->atom_list[i].name, "text/uri-list"))) + { + aret = strcat(aret, pd->atom_list[i].name); + aret = strcat(aret, sep); + } + } + } + *data_ret = aret; + if (size_ret) *size_ret = len; + + return EINA_TRUE; +} + +static Eina_Bool +_wl_general_converter(char *target, Sel_Manager_Selection *sel, void *data, int size, void **data_ret, int *size_ret) +{ + Efl_Selection_Format format = EFL_SELECTION_FORMAT_NONE; + Sel_Manager_Atom *atom = NULL; + Sel_Manager_Seat_Selection *seat_sel = sel->seat_sel; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + + sel_debug("in\n"); + + atom = eina_hash_find(pd->type_hash, target); + if (atom) + format = atom->format; + if (format == EFL_SELECTION_FORMAT_NONE) + { + if (data_ret) + { + *data_ret = malloc(size * sizeof(char) + 1); + if (!*data_ret) return EINA_FALSE; + memcpy(*data_ret, data, size); + ((char**)(data_ret))[0][size] = 0; + } + if (size_ret) *size_ret = size; + } + else + { + if (data) + { + if (data_ret) *data_ret = strdup(data); + if (size_ret) *size_ret = strlen(data); + } + else + { + if (data_ret) *data_ret = NULL; + if (size_ret) *size_ret = 0; + } + } + + return EINA_TRUE; +} + +static Eina_Bool +_wl_text_converter(char *target, Sel_Manager_Selection *sel, void *data, int size, void **data_ret, int *size_ret) +{ + Efl_Selection_Format format = EFL_SELECTION_FORMAT_NONE; + Sel_Manager_Atom *atom = NULL; + Sel_Manager_Seat_Selection *seat_sel = sel->seat_sel; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + + sel_debug("in\n"); + + atom = eina_hash_find(pd->type_hash, target); + if (atom) + format = atom->format; + if (format == EFL_SELECTION_FORMAT_NONE) + { + if (data_ret) + { + *data_ret = malloc(size * sizeof(char) + 1); + if (!*data_ret) return EINA_FALSE; + memcpy(*data_ret, data, size); + ((char**)(data_ret))[0][size] = 0; + if (size_ret) *size_ret = size; + return EINA_TRUE; + } + } + else if ((format & EFL_SELECTION_FORMAT_MARKUP) || + (format & EFL_SELECTION_FORMAT_HTML)) + { + *data_ret = _elm_util_mkup_to_text(data); + if (size_ret && *data_ret) *size_ret = strlen(*data_ret); + } + else if (format & EFL_SELECTION_FORMAT_TEXT) + { + *data_ret = strdup(data); + if (size_ret && *data_ret) *size_ret = strlen(*data_ret); + } + else if (format & EFL_SELECTION_FORMAT_IMAGE) + { + sel_debug("Image %s\n", evas_object_type_get(sel->request_obj)); + efl_file_get(sel->request_obj, (const char **)data_ret, NULL); + if (!*data_ret) *data_ret = strdup("No file"); + else *data_ret = strdup(*data_ret); + + if (!*data_ret) + { + ERR("Failed to allocate memory!"); + *size_ret = 0; + return EINA_FALSE; + } + + if (size_ret) *size_ret = strlen(*data_ret); + } + return EINA_TRUE; +} + +static void +_wl_sel_obj_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED) +{ + Sel_Manager_Selection *sel = data; + if (sel->owner == obj) + { + sel->owner = NULL; + } + //if (dragwidget == obj) dragwidget = NULL; +} + +static Eina_Future * +_wl_efl_sel_manager_selection_set(Efl_Selection_Manager_Data *pd, + Efl_Object *owner, Efl_Selection_Type type, + Efl_Selection_Format format, + Eina_Slice data, + Ecore_Wl2_Window *win, + unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + int i = 0, count = 0; + Eina_Bool is_uri = EINA_FALSE; + const char **types; + + if ((!data.mem) && (format != EFL_SELECTION_FORMAT_IMAGE)) + { + efl_selection_manager_selection_clear(pd->sel_man, owner, type, seat); + return NULL; + } + + if (data.len <= 0) + return NULL; + + seat_sel = _wl_sel_manager_seat_selection_init(pd, seat); + seat_sel->active_type = type; + sel = seat_sel->sel; + + if (sel->owner != owner) + { + Eina_List *l, *l_next; + Sel_Manager_Selection_Lost *sel_lost; + + EINA_LIST_FOREACH_SAFE(seat_sel->sel_lost_list, l, l_next, sel_lost) + { + if ((sel_lost->request == sel->owner) && + (sel_lost->type == type)) + { + eina_promise_resolve(sel_lost->promise, eina_value_uint_init(sel_lost->type)); + seat_sel->sel_lost_list = eina_list_remove(seat_sel->sel_lost_list, sel_lost); + free(sel_lost); + } + } + } + + if (sel->owner) + evas_object_event_callback_del_full(sel->owner, EVAS_CALLBACK_DEL, + _wl_sel_obj_del, sel); + sel->active = EINA_TRUE; + sel->owner = owner; + sel->win = win; + /* sel->set(win, &selection, sizeof(Elm_Sel_Type)); */ + sel->format = format; + + evas_object_event_callback_add + (sel->owner, EVAS_CALLBACK_DEL, _wl_sel_obj_del, &sel); + + sel->data = eina_slice_dup(data); + if (!sel->data.mem) + { + efl_selection_manager_selection_clear(pd->sel_man, owner, type, seat_sel->seat); + return NULL; + } + + is_uri = _wl_is_uri_type_data(sel->data.mem, sel->data.len); + types = malloc(sizeof(char *)); + if (!types) return NULL; + for (i = 0, count = 1; i < SELECTION_N_ATOMS; i++) + { + if (format & pd->atom_list[i].format) + { + if ((is_uri) || + ((!is_uri) && strcmp(pd->atom_list[i].name, "text/uri-list"))) + { + const char **t = NULL; + + types[count - 1] = pd->atom_list[i].name; + count++; + t = realloc(types, sizeof(char *) * count); + if (!t) + { + free(types); + return NULL; + } + types = t; + } + } + } + types[count - 1] = 0; + + sel->selection_serial = ecore_wl2_dnd_selection_set(_wl_seat_get(win, owner, seat_sel->seat), types); + ERR("serial: %d", sel->selection_serial); + + free(types); + //return _local_elm_cnp_selection_set(obj, selection, format, buf, buflen); + + return _update_sel_lost_list(owner, type, seat_sel); +} + +static void +_wl_selection_changed_free(void *data, void *ev EINA_UNUSED) +{ + ecore_wl2_display_disconnect(data); +} + +static Eina_Bool +_wl_selection_changed(void *data, int type EINA_UNUSED, void *event) +{ + Efl_Selection_Manager_Data *pd = data; + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + Efl_Selection_Changed e; + Ecore_Wl2_Event_Seat_Selection *ev = event; + Ecore_Wl2_Input *seat; + + seat_sel = _wl_sel_manager_seat_selection_init(pd, ev->seat); + sel_debug("seat: %d", ev->seat); + if (!seat_sel) return ECORE_CALLBACK_RENEW; + sel = seat_sel->sel; + + seat = ecore_wl2_display_input_find(ev->display, ev->seat); + EINA_SAFETY_ON_NULL_RETURN_VAL(seat, ECORE_CALLBACK_RENEW); + e.type = EFL_SELECTION_TYPE_CLIPBOARD; + e.seat = ev->seat; + /* connect again to add ref */ + e.display = ecore_wl2_display_connect(ecore_wl2_display_name_get(ev->display)); + e.exist = !!ecore_wl2_dnd_selection_get(seat); + //ecore_event_add(ELM_CNP_EVENT_SELECTION_CHANGED, e, _wl_selection_changed_free, ev->display); + //efl_event_callback_call(sel->request_obj, EFL_SELECTION_EVENT_SELECTION_CHANGED, &e); + + return ECORE_CALLBACK_RENEW; +} + +static Eina_Bool +_wl_selection_send(void *data, int type, void *event) +{ + Efl_Selection_Manager_Data *pd = data; + char *buf; + int ret, len_remained; + int len_written = 0; + Ecore_Wl2_Event_Data_Source_Send *ev; + int seat; + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + void *data_ret = NULL; + int len_ret = 0; + int i = 0; + + ev = event; + seat = ev->seat; + sel_debug("seat: %d, type: %d", seat, type); + seat_sel = _wl_sel_manager_seat_selection_init(pd, seat); + if (!seat_sel) return ECORE_CALLBACK_RENEW; + sel = seat_sel->sel; + + if ((ev->serial != sel->selection_serial) && + (ev->serial != sel->drag_serial)) + return ECORE_CALLBACK_RENEW; + + for (i = 0; i < SELECTION_N_ATOMS; i++) + { + if (!strcmp(pd->atom_list[i].name, ev->type)) + { + sel_debug("Found a type: %s\n", pd->atom_list[i].name); + Sel_Manager_Dropable *drop; + drop = efl_key_data_get(sel->request_obj, "__elm_dropable"); + if (drop) + drop->last.type = pd->atom_list[i].name; + if (pd->atom_list[i].wl_converter) + { + pd->atom_list[i].wl_converter(ev->type, sel, sel->data.mem, + sel->data.len, &data_ret, &len_ret); + } + else + { + data_ret = strdup(sel->data.mem); + len_ret = sel->data.len; + } + break; + } + } + + len_remained = len_ret; + buf = data_ret; + + while (len_written < len_ret) + { + ret = write(ev->fd, buf, len_remained); + if (ret == -1) break; + buf += ret; + len_written += ret; + len_remained -= ret; + } + free(data_ret); + + close(ev->fd); + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_wl_dnd_end(void *data, int type EINA_UNUSED, void *event) +{ + sel_debug("In"); + Efl_Selection_Manager_Data *pd = data; + Ecore_Wl2_Event_Data_Source_End *ev; + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + Ecore_Wl2_Window *win; + + ev = event; + seat_sel = _wl_sel_manager_seat_selection_init(pd, ev->seat); + sel = seat_sel->sel; + if (ev->serial != sel->drag_serial) + return ECORE_CALLBACK_RENEW; + + //efl_event_callback_call(seat_sel->drag_obj, EFL_UI_DND_EVENT_DRAG_DONE, NULL); + if (seat_sel->drag_win) + { + if (!seat_sel->accept) + { + /* Commit animation when drag cancelled */ + /* Record final position of dragwin, then do animation */ + ecore_animator_timeline_add(0.3, _drag_cancel_animate, seat_sel); + } + else + { + /* No animation drop was committed */ + evas_object_del(seat_sel->drag_win); + seat_sel->drag_win = NULL; + } + } + + seat_sel->accept = EINA_FALSE; + win = ecore_wl2_display_window_find(_elm_wl_display, ev->win); + ecore_wl2_input_ungrab(_wl_seat_get(win, NULL, seat_sel->seat)); + + return ECORE_CALLBACK_PASS_ON; +} + +static Ecore_Wl2_Input * +_wl_seat_get(Ecore_Wl2_Window *win, const Evas_Object *obj, unsigned int seat_id) +{ + Eo *seat, *parent2, *ewin; + Ecore_Wl2_Input *input = NULL; + + input = ecore_wl2_display_input_find(ecore_wl2_window_display_get(win), seat_id); + if (input) return input; + + if (obj) + { + // FIXME (there might be a better solution): + // In case of inwin, we want to use the main wl2 window for cnp, but obj + // obj belongs to the buffer canvas, so the default seat for obj does not + // match the window win. + Eo *top = elm_widget_top_get(obj); + if (efl_isa(top, EFL_UI_WIN_INLINED_CLASS)) + { + parent2 = efl_ui_win_inlined_parent_get(top); + if (parent2) obj = elm_widget_top_get(parent2) ?: parent2; + } + /* fake win means canvas seat id will not match protocol seat id */ + ewin = elm_win_get(obj); + if (elm_win_type_get(ewin) == ELM_WIN_FAKE) obj = NULL; + } + + if (!obj) + { + Eina_Iterator *it; + it = ecore_wl2_display_inputs_get(ecore_wl2_window_display_get(win)); + EINA_ITERATOR_FOREACH(it, input) break; + eina_iterator_free(it); + return input; + } + + seat = evas_canvas_default_device_get(evas_object_evas_get(obj), EFL_INPUT_DEVICE_TYPE_SEAT); + EINA_SAFETY_ON_NULL_RETURN_VAL(seat, NULL); + return ecore_wl2_display_input_find(ecore_wl2_window_display_get(win), + evas_device_seat_id_get(seat)); +} + +static Ecore_Wl2_Window * +_wl_window_get(const Evas_Object *obj) +{ + Evas_Object *top; + Ecore_Wl2_Window *win = NULL; + + if (elm_widget_is(obj)) + { + top = elm_widget_top_get(obj); + if (!top) top = elm_widget_top_get(elm_widget_parent_widget_get(obj)); + if (top && (efl_isa(top, EFL_UI_WIN_CLASS))) + win = elm_win_wl_window_get(top); + } + if (!win) + { + Ecore_Evas *ee; + Evas *evas; + const char *engine_name; + + if (!(evas = evas_object_evas_get(obj))) + return NULL; + if (!(ee = ecore_evas_ecore_evas_get(evas))) + return NULL; + + engine_name = ecore_evas_engine_name_get(ee); + if (!strcmp(engine_name, ELM_BUFFER)) + { + ee = ecore_evas_buffer_ecore_evas_parent_get(ee); + if (!ee) return NULL; + engine_name = ecore_evas_engine_name_get(ee); + } + if (!strncmp(engine_name, "wayland", sizeof("wayland") - 1)) + { + /* In case the engine is not a buffer, we want to check once. */ + win = ecore_evas_wayland2_window_get(ee); + if (!win) return NULL; + } + } + + return win; +} + +static void +_wl_selection_receive_timeout(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED) +{ + Sel_Manager_Selection *sel = data; + + if (sel->request_obj != obj) return; + + ecore_event_handler_del(sel->offer_handler); +} + +static Eina_Bool +_wl_selection_receive(void *data, int type EINA_UNUSED, void *event) +{ + Ecore_Wl2_Event_Offer_Data_Ready *ev = event; + Sel_Manager_Selection *sel = data; + ERR("in"); + + if (sel->sel_offer != ev->offer) return ECORE_CALLBACK_PASS_ON; + + if (sel->data_func) + { + Efl_Selection_Data sel_data; + + sel_data.pos.x = sel_data.pos.y = 0; + sel_data.format = sel->format; + sel_data.data.mem = ev->data; + sel_data.data.len = ev->len; + sel_data.action = _wl_to_elm(ecore_wl2_offer_action_get(sel->sel_offer)); + sel->data_func(sel->data_func_data, + sel->request_obj, + &sel_data); + } + else + { + char *stripstr, *mkupstr; + + stripstr = malloc(ev->len + 1); + if (!stripstr) return ECORE_CALLBACK_CANCEL; + strncpy(stripstr, (char *)ev->data, ev->len); + stripstr[ev->len] = '\0'; + mkupstr = _elm_util_text_to_mkup((const char *)stripstr); + /* TODO BUG: should never NEVER assume it's an elm_entry! */ + _elm_entry_entry_paste(sel->request_obj, mkupstr); + free(stripstr); + free(mkupstr); + } + + evas_object_event_callback_del_full(sel->request_obj, + EVAS_CALLBACK_DEL, + _wl_selection_receive_timeout, sel); + + ecore_event_handler_del(sel->offer_handler); + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_wl_efl_sel_manager_selection_get(const Efl_Object *request, Efl_Selection_Manager_Data *pd, + Efl_Selection_Type type, Efl_Selection_Format format, + void *data_func_data, Efl_Selection_Data_Ready data_func, Eina_Free_Cb data_func_free_cb, + Ecore_Wl2_Window *win, unsigned int seat) +{ + sel_debug("In, format: %d", format); + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + Ecore_Wl2_Input *input; + Ecore_Wl2_Offer *offer; + int i = 0; + + if (type == EFL_SELECTION_TYPE_DND) return EINA_FALSE; + + //if (sel->active) + //return _local_elm_cnp_selection_get(obj, selection, format, datacb, udata); + seat_sel = _sel_manager_seat_selection_init(pd, seat); + sel = seat_sel->sel; + sel->request_obj = (Efl_Object *)request; + sel->data_func_data = data_func_data; + sel->data_func = data_func; + sel->data_func_free_cb = data_func_free_cb; + + input = _wl_seat_get(win, request, seat_sel->seat); + offer = ecore_wl2_dnd_selection_get(input); + + //there can be no selection available + if (!offer) return EINA_FALSE; + + for (i = 0; sm_wl_convertion[i].translates; i++) + { + int j = 0; + if (!(format & sm_wl_convertion[i].format)) continue; + + for (j = 0; sm_wl_convertion[i].translates[j]; j++) + { + if (!ecore_wl2_offer_supports_mime(offer, sm_wl_convertion[i].translates[j])) continue; + + //we have found matching mimetypes + sel->sel_offer = offer; + sel->format = sm_wl_convertion[i].format; + + sel_debug("request type: %s", (char *)sm_wl_convertion[i].translates[j]); + evas_object_event_callback_add(sel->request_obj, EVAS_CALLBACK_DEL, + _wl_selection_receive_timeout, sel); + sel->offer_handler = ecore_event_handler_add(ECORE_WL2_EVENT_OFFER_DATA_READY, + _wl_selection_receive, sel); + + ecore_wl2_offer_receive(offer, (char*)sm_wl_convertion[i].translates[j]); + return EINA_TRUE; + } + } + + sel_debug("no type match"); + return EINA_FALSE; +} + +static void +_wl_sel_obj_del2(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED) +{ + Sel_Manager_Selection *sel = data; + if (sel->request_obj == obj) sel->request_obj = NULL; +} + +static Sel_Manager_Dropable * +_wl_dropable_find(Efl_Selection_Manager_Data *pd, unsigned int win) +{ + Eina_List *l; + Sel_Manager_Dropable *dropable; + Ecore_Wl2_Window *window; + + if (!pd->drop_list) return NULL; + + window = ecore_wl2_display_window_find(_elm_wl_display, win); + if (!window) return NULL; + + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + if (_wl_window_get(dropable->obj) == window) + return dropable; + + return NULL; +} + +static Evas * +_wl_evas_get_from_win(Efl_Selection_Manager_Data *pd, unsigned int win) +{ + Sel_Manager_Dropable *dropable = _wl_dropable_find(pd, win); + return dropable ? evas_object_evas_get(dropable->obj) : NULL; +} + +static Eina_Bool +_wl_drops_accept(Sel_Manager_Seat_Selection *seat_sel, const char *type) +{ + Efl_Selection_Manager_Data *pd; + Sel_Manager_Selection *sel; + Eina_List *l; + Sel_Manager_Dropable *drop; + Eina_Bool will_accept = EINA_FALSE; + + if (!type) return EINA_FALSE; + + pd = seat_sel->pd; + sel = seat_sel->sel; + EINA_LIST_FOREACH(pd->drop_list, l, drop) + { + Drop_Format *df; + EINA_INLIST_FOREACH(drop->format_list, df) + { + for (int i = 0; sm_wl_convertion[i].translates ; ++i) + { + if (!(sm_wl_convertion[i].format & df->format)) continue; + + for (int j = 0; sm_wl_convertion[i].translates[j]; ++j) + { + if (!strncmp(type, sm_wl_convertion[i].translates[j], strlen(sm_wl_convertion[i].translates[j]))) + { + sel->request_obj = drop->obj; + return EINA_TRUE; + } + } + } + } + } + + return will_accept; +} + +static void +_wl_selection_parser(void *_data, int size, char ***ret_data, int *ret_count) +{ + char **files = NULL; + int num_files = 0; + char *data = NULL; + + data = malloc(size); + if (data && (size > 0)) + { + int i, is; + char *tmp; + char **t2; + + memcpy(data, _data, size); + if (data[size - 1]) + { + char *t; + + /* Isn't nul terminated */ + size++; + t = realloc(data, size); + if (!t) goto done; + data = t; + data[size - 1] = 0; + } + + tmp = malloc(size); + if (!tmp) goto done; + i = 0; + is = 0; + while ((is < size) && (data[is])) + { + if ((i == 0) && (data[is] == '#')) + for (; ((data[is]) && (data[is] != '\n')); is++) ; + else + { + if ((data[is] != '\r') && (data[is] != '\n')) + tmp[i++] = data[is++]; + else + { + while ((data[is] == '\r') || (data[is] == '\n')) + is++; + tmp[i] = 0; + num_files++; + t2 = realloc(files, num_files * sizeof(char *)); + if (t2) + { + files = t2; + files[num_files - 1] = strdup(tmp); + } + else + { + num_files--; + goto freetmp; + } + tmp[0] = 0; + i = 0; + } + } + } + if (i > 0) + { + tmp[i] = 0; + num_files++; + t2 = realloc(files, num_files * sizeof(char *)); + if (t2) + { + files = t2; + files[num_files - 1] = strdup(tmp); + } + else + { + num_files--; + goto freetmp; + } + } +freetmp: + free(tmp); + } +done: + free(data); + if (ret_data) *ret_data = files; + else + { + int i; + + for (i = 0; i < num_files; i++) free(files[i]); + free(files); + } + if (ret_count) *ret_count = num_files; +} + +static Eina_Bool +_wl_data_preparer_markup(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info EINA_UNUSED) +{ + sel_debug("In\n"); + + ddata->format = EFL_SELECTION_FORMAT_MARKUP; + ddata->data.mem = eina_memdup((unsigned char *)ev->data, ev->len, EINA_TRUE); + ddata->data.len = ev->len; + ddata->action = sel->action; + + return EINA_TRUE; +} + +static Eina_Bool +_wl_data_preparer_uri(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info EINA_UNUSED) +{ + Sel_Manager_Seat_Selection *seat_sel; + char *p, *stripstr = NULL; + char *data = ev->data; + Sel_Manager_Dropable *drop; + const char *type = NULL; + + sel_debug("In\n"); + + seat_sel = sel->seat_sel; + drop = efl_key_data_get(sel->request_obj, "__elm_dropable"); + if (drop) type = drop->last.type; + + if ((type) && (!strcmp(type, "text/uri-list"))) + { + int num_files = 0; + char **files = NULL; + Efreet_Uri *uri; + Eina_Strbuf *strbuf; + int i; + + strbuf = eina_strbuf_new(); + if (!strbuf) return EINA_FALSE; + + _wl_selection_parser(ev->data, ev->len, &files, &num_files); + sel_debug("got a files list\n"); + + for (i = 0; i < num_files; i++) + { + uri = efreet_uri_decode(files[i]); + if (uri) + { + eina_strbuf_append(strbuf, uri->path); + efreet_uri_free(uri); + } + else + { + eina_strbuf_append(strbuf, files[i]); + } + if (i < (num_files - 1)) + eina_strbuf_append(strbuf, "\n"); + free(files[i]); + } + free(files); + stripstr = eina_strbuf_string_steal(strbuf); + eina_strbuf_free(strbuf); + } + else + { + Efreet_Uri *uri; + + p = (char *)eina_memdup((unsigned char *)data, ev->len, EINA_TRUE); + if (!p) return EINA_FALSE; + uri = efreet_uri_decode(p); + if (!uri) + { + /* Is there any reason why we care of URI without scheme? */ + if (p[0] == '/') stripstr = p; + else free(p); + } + else + { + free(p); + stripstr = strdup(uri->path); + efreet_uri_free(uri); + } + } + + if (!stripstr) + { + sel_debug("Couldn't find a file\n"); + return EINA_FALSE; + } + free(seat_sel->saved_types->imgfile); + + ddata->data.mem = stripstr; + ddata->data.len = strlen(stripstr); + ddata->action = sel->action; + ddata->format = sel->request_format; + + return EINA_TRUE; +} + +static Eina_Bool +_wl_data_preparer_vcard(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info EINA_UNUSED) +{ + sel_debug("In\n"); + + ddata->format = EFL_SELECTION_FORMAT_VCARD; + ddata->data.mem = eina_memdup((unsigned char *)ev->data, ev->len, EINA_TRUE); + ddata->data.len = ev->len; + ddata->action = sel->action; + + return EINA_TRUE; +} + +static Eina_Bool +_wl_data_preparer_image(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info) +{ + sel_debug("In\n"); + Tmp_Info *tmp; + int len = 0; + + tmp = _tempfile_new(ev->len); + if (!tmp) + return EINA_FALSE; + memcpy(tmp->map, ev->data, ev->len); + munmap(tmp->map, ev->len); + + len = strlen(tmp->filename); + ddata->format = EFL_SELECTION_FORMAT_IMAGE; + ddata->data.mem = eina_memdup((unsigned char*)tmp->filename, len, EINA_TRUE); + ddata->data.len = len; + ddata->action = sel->action; + *tmp_info = tmp; + + return EINA_TRUE; +} + +static Eina_Bool +_wl_data_preparer_text(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info EINA_UNUSED) +{ + sel_debug("In\n"); + + ddata->format = EFL_SELECTION_FORMAT_TEXT; + ddata->data.mem = eina_memdup((unsigned char *)ev->data, ev->len, EINA_TRUE); + ddata->data.len = ev->len; + ddata->action = sel->action; + + return EINA_TRUE; +} + + +static void +_wl_dropable_handle(Sel_Manager_Seat_Selection *seat_sel, Sel_Manager_Dropable *dropable, Evas_Coord x, Evas_Coord y) +{ + Sel_Manager_Dropable *d, *last_dropable = NULL; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + Sel_Manager_Selection *sel; + Eina_Inlist *itr; + Eina_List *l; + Eina_Position2D pos; + + EINA_LIST_FOREACH(pd->drop_list, l, d) + { + if (d->last.in) + { + last_dropable = d; + break; + } + } + + sel = seat_sel->sel; + pos = EINA_POSITION2D(x, y); + /* If we are on the same object, just update the position */ + if ((dropable) && (last_dropable == dropable)) + { + Evas_Coord ox, oy; + Efl_Dnd_Drag_Pos pos_data; + Drop_Format *df; + + evas_object_geometry_get(dropable->obj, &ox, &oy, NULL, NULL); + if (!dropable->is_container) + { + pos_data.pos = EINA_POSITION2D(x - ox, y - oy); + pos_data.item = NULL; + } + else + { + Efl_Object *it = NULL; + + if (dropable->item_func) + it = dropable->item_func(dropable->item_func_data, dropable->obj, + pos, &pos_data.pos); + pos_data.item = it; + } + pos_data.format = dropable->last.format; + pos_data.action = sel->action; + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + if (df->format & dropable->last.format) + { + //efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_POS, &pos_data); + } + } + + return; + } + /* We leave the last dropable */ + if (last_dropable) + { + Drop_Format *df; + sel_debug("leave %p\n", last_dropable->obj); + last_dropable->last.in = EINA_FALSE; + + EINA_INLIST_FOREACH_SAFE(last_dropable->format_list, itr, df) + { + //if (df->format & last_dropable->last.format) + // efl_event_callback_call(last_dropable->obj, EFL_UI_DND_EVENT_DRAG_LEAVE, NULL); + } + } + /* We enter the new dropable */ + if (dropable) + { + sel_debug("enter %p\n", dropable->obj); + Evas_Coord ox, oy; + Efl_Dnd_Drag_Pos pos_data; + Drop_Format *df; + + dropable->last.in = EINA_TRUE; + evas_object_geometry_get(dropable->obj, &ox, &oy, NULL, NULL); + if (!dropable->is_container) + { + pos_data.pos = EINA_POSITION2D(x - ox, y - oy); + pos_data.item = NULL; + } + else + { + Efl_Object *it = NULL; + + if (dropable->item_func) + it = dropable->item_func(dropable->item_func_data, dropable->obj, + pos, &pos_data.pos); + pos_data.item = it; + } + pos_data.format = dropable->last.format; + pos_data.action = sel->action; + + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + if (df->format & dropable->last.format) + { + //efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_ENTER, NULL); + //efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_POS, &pos_data); + } + } + } +} + +static void +_wl_dropable_all_clean(Sel_Manager_Seat_Selection *seat_sel, unsigned int win) +{ + Eina_List *l; + Sel_Manager_Dropable *dropable; + Ecore_Wl2_Window *window; + + window = ecore_wl2_display_window_find(_elm_wl_display, win); + if (!window) return; + + EINA_LIST_FOREACH(seat_sel->pd->drop_list, l, dropable) + { + if (_wl_window_get(dropable->obj) == window) + { + dropable->last.pos.x = 0; + dropable->last.pos.y = 0; + dropable->last.in = EINA_FALSE; + } + } +} + +static void +_wl_dropable_data_handle(Sel_Manager_Selection *sel, Ecore_Wl2_Event_Offer_Data_Ready *ev) +{ + Sel_Manager_Seat_Selection *seat_sel; + Efl_Selection_Manager_Data *pd; + Sel_Manager_Dropable *drop; + Ecore_Wl2_Window *win; + + sel_debug("In\n"); + seat_sel = sel->seat_sel; + pd = seat_sel->pd; + drop = efl_key_data_get(sel->request_obj, "__elm_dropable"); + if (drop) + { + Sel_Manager_Atom *atom = NULL; + + atom = eina_hash_find(pd->type_hash, drop->last.type); + if (atom && atom->wl_data_preparer) + { + Efl_Selection_Data ddata; + Tmp_Info *tmp_info = NULL; + Eina_Bool success; + + sel_debug("Call notify for: %s\n", atom->name); + success = atom->wl_data_preparer(sel, &ddata, ev, &tmp_info); + if (success) + { + Sel_Manager_Dropable *dropable; + Eina_List *l; + + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + { + if (dropable->obj == sel->request_obj) break; + dropable = NULL; + } + if (dropable) + { + Drop_Format *df; + Eina_Inlist *itr; + + if (!dropable->is_container) + { + ddata.pos.x = seat_sel->saved_types->pos.x; + ddata.pos.y = seat_sel->saved_types->pos.y; + } + else + { + //for container + Efl_Object *it = NULL; + Evas_Coord x0 = 0, y0 = 0; + Eina_Position2D pos, posret; + + evas_object_geometry_get(dropable->obj, &x0, &y0, NULL, NULL); + pos = EINA_POSITION2D(seat_sel->saved_types->pos.x + x0, + seat_sel->saved_types->pos.y + y0); + if (dropable->item_func) + it = dropable->item_func(dropable->item_func_data, dropable->obj, + pos, &posret); + ddata.pos = posret; + ddata.item = it; + } + ddata.action = seat_sel->drag_action; + + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + //if (df->format & dropable->last.format) + // efl_event_callback_call(dropable->obj, EFL_UI_DND_EVENT_DRAG_DROP, &ddata); + } + } + } + win = _wl_window_get(sel->request_obj); + ecore_wl2_dnd_drag_end(_wl_seat_get(win, NULL, seat_sel->seat)); + if (tmp_info) _tmpinfo_free(tmp_info); + return; + } + } + + win = _wl_window_get(sel->request_obj); + ecore_wl2_dnd_drag_end(_wl_seat_get(win, NULL, seat_sel->seat)); + seat_sel->saved_types->textreq = 0; +} + +static Eina_Bool +_wl_dnd_enter(void *data, int type EINA_UNUSED, void *event) +{ + Ecore_Wl2_Event_Dnd_Enter *ev; + Eina_Array *known, *available; + Sel_Manager_Seat_Selection *seat_sel = data; + unsigned int i = 0; + + ev = event; + + available = ecore_wl2_offer_mimes_get(ev->offer); + + free(seat_sel->saved_types->types); + + seat_sel->saved_types->ntypes = eina_array_count(available); + seat_sel->saved_types->types = malloc(sizeof(char *) * seat_sel->saved_types->ntypes); + if (!seat_sel->saved_types->types) return EINA_FALSE; + + known = eina_array_new(5); + + for (i = 0; i < eina_array_count(available); i++) + { + seat_sel->saved_types->types[i] = + eina_stringshare_add(eina_array_data_get(available, i)); + if (seat_sel->saved_types->types[i] == seat_sel->pd->text_uri) + { + seat_sel->saved_types->textreq = 1; + ELM_SAFE_FREE(seat_sel->saved_types->imgfile, free); + } + } + + seat_sel->accept = EINA_FALSE; + for (i = 0; i < eina_array_count(available); i++) + { + if (_wl_drops_accept(seat_sel, eina_array_data_get(available, i))) + { + eina_array_push(known, strdup(eina_array_data_get(available, i))); + } + } + + ecore_wl2_offer_mimes_set(ev->offer, known); + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_wl_dnd_leave(void *data, int type EINA_UNUSED, void *event) +{ + Ecore_Wl2_Event_Dnd_Leave *ev; + Sel_Manager_Seat_Selection *seat_sel = data; + Sel_Manager_Dropable *drop; + sel_debug("In\n"); + + ev = event; + if ((drop = _wl_dropable_find(seat_sel->pd, ev->win))) + { + _wl_dropable_handle(seat_sel, NULL, 0, 0); + _wl_dropable_all_clean(seat_sel, ev->win); + } + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_wl_dnd_position(void *data, int type EINA_UNUSED, void *event) +{ + Ecore_Wl2_Event_Dnd_Motion *ev; + Sel_Manager_Seat_Selection *seat_sel = data; + Efl_Selection_Manager_Data *pd = seat_sel->pd; + Sel_Manager_Dropable *drop; + Eina_Bool will_accept = EINA_FALSE; + + ev = event; + + sel_debug("mouse pos %i %i\n", ev->x, ev->y); + seat_sel->drag_win_end.x = ev->x - seat_sel->drag_pos.x; + seat_sel->drag_win_end.y = ev->y - seat_sel->drag_pos.y; + + drop = _wl_dropable_find(pd, ev->win); + + if (drop) + { + Eina_Position2D pos = EINA_POSITION2D(ev->x, ev->y); + Evas *evas = NULL; + Eina_List *dropable_list = NULL; + + _dropable_coords_adjust(drop, &pos); + evas = _wl_evas_get_from_win(pd, ev->win); + if (evas) + dropable_list = _dropable_list_geom_find(pd, evas, pos.x, pos.y); + + /* check if there is dropable (obj) can accept this drop */ + if (dropable_list) + { + Efl_Selection_Format saved_format; + Eina_List *l; + Eina_Bool found = EINA_FALSE; + Sel_Manager_Dropable *dropable = NULL; + + saved_format = + _dnd_types_to_format(pd, seat_sel->saved_types->types, seat_sel->saved_types->ntypes); + + EINA_LIST_FOREACH(dropable_list, l, dropable) + { + Drop_Format *df; + Eina_Inlist *itr; + + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + Efl_Selection_Format common_fmt = saved_format & df->format; + + if (common_fmt) + { + /* We found a target that can accept this type of data */ + int i, min_index = SELECTION_N_ATOMS; + + /* We have to find the first atom that corresponds to one + * of the supported data types. */ + for (i = 0; i < seat_sel->saved_types->ntypes; i++) + { + Sel_Manager_Atom *atom; + + atom = eina_hash_find(pd->type_hash, + seat_sel->saved_types->types[i]); + + if (atom && (atom->format & common_fmt)) + { + int atom_idx = (atom - pd->atom_list); + + if (min_index > atom_idx) + min_index = atom_idx; + } + } + if (min_index != SELECTION_N_ATOMS) + { + sel_debug("Found atom %s\n", pd->atom_list[min_index].name); + found = EINA_TRUE; + dropable->last.type = pd->atom_list[min_index].name; + dropable->last.format = common_fmt; + break; + } + } + } + if (found) break; + } + if (found) + { + Sel_Manager_Selection *sel = seat_sel->sel; + Evas_Coord ox = 0, oy = 0; + + evas_object_geometry_get(dropable->obj, &ox, &oy, NULL, NULL); + + sel_debug("Candidate %p (%s)\n", + dropable->obj, efl_class_name_get(efl_class_get(dropable->obj))); + _wl_dropable_handle(seat_sel, dropable, pos.x - ox, pos.y - oy); + sel->request_obj = dropable->obj; + will_accept = EINA_TRUE; + } + else + { + //if not: send false status + sel_debug("dnd position (%d, %d) not in obj\n", pos.x, pos.y); + _wl_dropable_handle(seat_sel, NULL, 0, 0); + // CCCCCCC: call dnd exit on last obj + } + eina_list_free(dropable_list); + } + } + + seat_sel->accept = will_accept; + //efl_event_callback_call(seat_sel->drag_obj, EFL_UI_DND_EVENT_DRAG_ACCEPT, &seat_sel->accept); + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_wl_dnd_receive(void *data, int type EINA_UNUSED, void *event) +{ + Ecore_Wl2_Event_Offer_Data_Ready *ev; + Sel_Manager_Seat_Selection *seat_sel = data; + Sel_Manager_Selection *sel; + Ecore_Wl2_Offer *offer; + sel_debug("In\n"); + + ev = event; + sel = seat_sel->sel; + offer = sel->dnd_offer; + + if (offer != ev->offer) return ECORE_CALLBACK_PASS_ON; + + if (sel->request_obj) + { + Ecore_Wl2_Drag_Action action; + + action = ecore_wl2_offer_action_get(ev->offer); + if (action == ECORE_WL2_DRAG_ACTION_ASK) + ecore_wl2_offer_actions_set(ev->offer, ECORE_WL2_DRAG_ACTION_COPY, ECORE_WL2_DRAG_ACTION_COPY); + action = ecore_wl2_offer_action_get(ev->offer); + sel->action = _wl_to_elm(action); + + _wl_dropable_data_handle(sel, ev); + evas_object_event_callback_del_full(sel->request_obj, + EVAS_CALLBACK_DEL, + _wl_sel_obj_del2, sel); + sel->request_obj = NULL; + } + + ecore_wl2_offer_finish(ev->offer); + + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_wl_dnd_drop(void *data, int type EINA_UNUSED, void *event) +{ + Ecore_Wl2_Event_Dnd_Drop *ev; + Sel_Manager_Seat_Selection *seat_sel = data; + Efl_Selection_Manager_Data *pd; + Sel_Manager_Selection *sel; + Ecore_Wl2_Window *win; + Sel_Manager_Dropable *drop; + Eina_List *l; + + sel_debug("In\n"); + ev = event; + seat_sel->saved_types->pos = EINA_POSITION2D(ev->x, ev->y); + pd = seat_sel->pd; + sel = seat_sel->sel; + sel->dnd_offer = ev->offer; + + EINA_LIST_FOREACH(pd->drop_list, l, drop) + { + if (drop->last.in) + { + sel_debug("Request data of type %s; drop: %p\n", drop->last.type, drop); + sel->request_obj = drop->obj; + sel->request_format = drop->last.format; + evas_object_event_callback_add(sel->request_obj, + EVAS_CALLBACK_DEL, _wl_sel_obj_del2, + sel); + win = _wl_window_get(drop->obj); + ecore_wl2_offer_receive(ev->offer, (char*)drop->last.type); + ecore_event_handler_add(ECORE_WL2_EVENT_OFFER_DATA_READY, _wl_dnd_receive, seat_sel); + + return ECORE_CALLBACK_PASS_ON; + } + } + + win = ecore_wl2_display_window_find(pd->wl_display, ev->win); + ecore_wl2_dnd_drag_end(_wl_seat_get(win, NULL, seat_sel->seat)); + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_wl_sel_manager_drop_target_add(Efl_Selection_Manager_Data *pd, Efl_Object *target_obj, + Efl_Selection_Format format, unsigned int seat) +{ + Sel_Manager_Dropable *dropable = NULL; + Sel_Manager_Seat_Selection *seat_sel = NULL; + Drop_Format *df; + + df = calloc(1, sizeof(Drop_Format)); + if (!df) return EINA_FALSE; + df->format = format; + dropable = efl_key_data_get(target_obj, "__elm_dropable"); + if (!dropable) + { + //Create new drop + dropable = calloc(1, sizeof(Sel_Manager_Dropable)); + if (!dropable) return EINA_FALSE; + pd->drop_list = eina_list_append(pd->drop_list, dropable); + if (!pd->drop_list) + { + free(dropable); + return EINA_FALSE; + } + dropable->obj = target_obj; + efl_key_data_set(target_obj, "__elm_dropable", dropable); + } + + dropable->format_list = eina_inlist_append(dropable->format_list, EINA_INLIST_GET(df)); + dropable->seat = seat; + seat_sel = _wl_sel_manager_seat_selection_init(pd, seat); + + evas_object_event_callback_add(target_obj, EVAS_CALLBACK_DEL, + _all_drop_targets_cbs_del, pd); + + if (!seat_sel->enter_handler) + { + seat_sel->enter_handler = + ecore_event_handler_add(ECORE_WL2_EVENT_DND_ENTER, + _wl_dnd_enter, seat_sel); + seat_sel->leave_handler = + ecore_event_handler_add(ECORE_WL2_EVENT_DND_LEAVE, + _wl_dnd_leave, seat_sel); + seat_sel->pos_handler = + ecore_event_handler_add(ECORE_WL2_EVENT_DND_MOTION, + _wl_dnd_position, seat_sel); + seat_sel->drop_handler = + ecore_event_handler_add(ECORE_WL2_EVENT_DND_DROP, + _wl_dnd_drop, seat_sel); + } + + return EINA_TRUE; +} +#endif + +#ifdef HAVE_ELEMENTARY_COCOA +static Sel_Manager_Seat_Selection * +_cocoa_sel_manager_seat_selection_init(Efl_Selection_Manager_Data *pd, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel = NULL; + Eina_List *l = NULL; + + EINA_LIST_FOREACH(pd->seat_list, l, seat_sel) + { + if(seat_sel->seat == seat) + break; + } + if (!seat_sel) + { + seat_sel = calloc(1, sizeof(Sel_Manager_Seat_Selection)); + if (!seat_sel) + { + ERR("Failed to allocate seat"); + return NULL; + } + seat_sel->saved_types = calloc(1, sizeof(Saved_Type)); + seat_sel->seat = seat; + seat_sel->pd = pd; + pd->seat_list = eina_list_append(pd->seat_list, seat_sel); + } + if (!seat_sel->sel) + { + Sel_Manager_Selection *sel = calloc(1, sizeof(Sel_Manager_Selection)); + if (!sel) + { + ERR("failed to allocate selection"); + return NULL; + } + sel->seat_sel = seat_sel; + seat_sel->sel = sel; + } + + return seat_sel; +} + +static Ecore_Cocoa_Window * +_cocoa_window_get(const Evas_Object *obj) +{ + Evas_Object *top, *par; + Ecore_Cocoa_Window *win = NULL; + + if (elm_widget_is(obj)) + { + top = elm_widget_top_get(obj); + if (!top) + { + par = elm_widget_parent_widget_get(obj); + if (par) top = elm_widget_top_get(par); + } + if ((top) && (efl_isa(top, EFL_UI_WIN_CLASS))) + win = elm_win_cocoa_window_get(top); + } + if (!win) + { + // FIXME + CRI("WIN has not been retrieved!!!"); + } + + return win; +} + +static Ecore_Cocoa_Cnp_Type +_sel_format_to_ecore_cocoa_cnp_type(Efl_Selection_Format fmt) +{ + Ecore_Cocoa_Cnp_Type type = 0; + + if ((fmt & EFL_SELECTION_FORMAT_TEXT) || + (fmt & EFL_SELECTION_FORMAT_VCARD)) + type |= ECORE_COCOA_CNP_TYPE_STRING; + if (fmt & EFL_SELECTION_FORMAT_MARKUP) + type |= ECORE_COCOA_CNP_TYPE_MARKUP; + if (fmt & EFL_SELECTION_FORMAT_HTML) + type |= ECORE_COCOA_CNP_TYPE_HTML; + if (fmt & EFL_SELECTION_FORMAT_IMAGE) + type |= ECORE_COCOA_CNP_TYPE_IMAGE; + + return type; +} + +static void +_cocoa_sel_obj_del_req_cb(void *data, + Evas *e EINA_UNUSED, + Evas_Object *obj, + void *ev_info EINA_UNUSED) +{ + Sel_Manager_Selection *sel = data; + if (sel->request_obj == obj) sel->request_obj = NULL; +} + +static void +_cocoa_sel_obj_del_cb(void *data, + Evas *e EINA_UNUSED, + Evas_Object *obj, + void *ev_info EINA_UNUSED) +{ + Sel_Manager_Selection *sel = data; + if (sel->owner == obj) + { + sel->owner = NULL; + } + //if (dragwidget == obj) dragwidget = NULL; +} + +static void +_job_pb_cb(void *data) +{ + Sel_Manager_Selection *sel = data; + Efl_Selection_Data ddata; + Ecore_Cocoa_Cnp_Type type, get_type; + void *pbdata; + int pbdata_len; + + if (sel->data_func) + { + ddata.pos.x = 0; + ddata.pos.y = 0; + + /* Pass to cocoa clipboard */ + type = _sel_format_to_ecore_cocoa_cnp_type(sel->request_format); + pbdata = ecore_cocoa_clipboard_get(&pbdata_len, type, &get_type); + + ddata.format = EFL_SELECTION_FORMAT_NONE; + if (get_type & ECORE_COCOA_CNP_TYPE_STRING) + ddata.format |= EFL_SELECTION_FORMAT_TEXT; + if (get_type & ECORE_COCOA_CNP_TYPE_MARKUP) + ddata.format |= EFL_SELECTION_FORMAT_MARKUP; + if (get_type & ECORE_COCOA_CNP_TYPE_IMAGE) + ddata.format |= EFL_SELECTION_FORMAT_IMAGE; + if (get_type & ECORE_COCOA_CNP_TYPE_HTML) + ddata.format |= EFL_SELECTION_FORMAT_HTML; + + ddata.data.mem = pbdata; + ddata.data.len = pbdata_len; + ddata.action = EFL_SELECTION_ACTION_UNKNOWN; + sel->data_func(sel->data_func_data, sel->request_obj, &ddata); + free(pbdata); + } +} + +static Eina_Future * +_cocoa_efl_sel_manager_selection_set(Efl_Selection_Manager_Data *pd, + Evas_Object *owner, + Efl_Selection_Type type, + Efl_Selection_Format format, + Eina_Slice data, + Ecore_Cocoa_Window *win, + unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + Ecore_Cocoa_Cnp_Type ecore_type; + Eina_List *l, *l_next; + Sel_Manager_Selection_Lost *sel_lost; + + seat_sel = _cocoa_sel_manager_seat_selection_init(pd, seat); + seat_sel->active_type = type; + sel = seat_sel->sel; + if ((!data.mem) && (format != EFL_SELECTION_FORMAT_IMAGE)) + { + efl_selection_manager_selection_clear(pd->sel_man, owner, type, seat); + return NULL; + } + if (data.len <= 0) return NULL; + + EINA_LIST_FOREACH_SAFE(seat_sel->sel_lost_list, l, l_next, sel_lost) + { + if ((sel_lost->request == sel->owner) && + (sel_lost->type == type)) + { + eina_promise_resolve(sel_lost->promise, eina_value_uint_init(sel_lost->type)); + seat_sel->sel_lost_list = eina_list_remove(seat_sel->sel_lost_list, sel_lost); + free(sel_lost); + } + } + if (sel->owner) + evas_object_event_callback_del_full(sel->owner, EVAS_CALLBACK_DEL, + _cocoa_sel_obj_del_cb, sel); + + sel->owner = owner; + sel->win = win; + sel->format = format; + + evas_object_event_callback_add(sel->owner, EVAS_CALLBACK_DEL, + _cocoa_sel_obj_del_cb, sel); + ELM_SAFE_FREE(sel->data.mem, free); + sel->data = eina_slice_dup(data); + if (sel->data.mem) + { + ecore_type = _sel_format_to_ecore_cocoa_cnp_type(format); + ecore_cocoa_clipboard_set(sel->data.mem, sel->data.len, ecore_type); + } + else + { + CRI("Failed to allocate memory!"); + efl_selection_manager_selection_clear(pd->sel_man, owner, type, seat_sel->seat); + return NULL; + } + + return _update_sel_lost_list(owner, type, seat_sel); +} + +static void +_cocoa_efl_sel_manager_selection_get(const Efl_Object *request, + Efl_Selection_Manager_Data *pd, + Efl_Selection_Type type EINA_UNUSED, + Efl_Selection_Format format, + void *data_func_data, Efl_Selection_Data_Ready data_func, Eina_Free_Cb data_func_free_cb, + Ecore_Cocoa_Window *win, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + + seat_sel = _sel_manager_seat_selection_init(pd, seat); + sel = seat_sel->sel; + sel->request_format = format; + sel->request_obj = (Efl_Object *)request; + sel->data_func_data = data_func_data; + sel->data_func = data_func; + sel->data_func_free_cb = data_func_free_cb; + if (sel->request_obj) + evas_object_event_callback_del_full(sel->request_obj, EVAS_CALLBACK_DEL, + _cocoa_sel_obj_del_req_cb, sel); + + sel->win = win; + ecore_job_add(_job_pb_cb, sel); + + evas_object_event_callback_add(sel->request_obj, EVAS_CALLBACK_DEL, + _cocoa_sel_obj_del_req_cb, sel); +} + +#endif + +// win32 specific stuff +//////////////////////////////////////////////////////////////////////////// +#ifdef HAVE_ELEMENTARY_WIN32 +static Sel_Manager_Seat_Selection * +_win32_sel_manager_seat_selection_init(Efl_Selection_Manager_Data *pd, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel = NULL; + Eina_List *l = NULL; + + EINA_LIST_FOREACH(pd->seat_list, l, seat_sel) + { + if(seat_sel->seat == seat) + break; + } + if (!seat_sel) + { + seat_sel = calloc(1, sizeof(Sel_Manager_Seat_Selection)); + if (!seat_sel) + { + ERR("Failed to allocate seat"); + return NULL; + } + seat_sel->saved_types = calloc(1, sizeof(Saved_Type)); + seat_sel->seat = seat; + seat_sel->pd = pd; + pd->seat_list = eina_list_append(pd->seat_list, seat_sel); + } + if (!seat_sel->sel_list) + { + seat_sel->sel_list = calloc(1, (EFL_SELECTION_TYPE_CLIPBOARD + 1) * sizeof(Sel_Manager_Selection)); + if (!seat_sel->sel_list) + { + ERR("failed to allocate selection list"); + return NULL; + } + _set_selection_list(seat_sel->sel_list, seat_sel); + } + + return seat_sel; +} + +static char * +_win32_text_n_to_rn(char *intext) +{ + size_t size = 0, newlines = 0; + char *outtext = NULL, *p, *o; + + if (!intext) return NULL; + for (p = intext; *p; p++) + { + if (*p == '\n') newlines++; + size++; + } + outtext = malloc(size + newlines + 1); + if (!outtext) return intext; + for (p = intext, o = outtext; *p; p++, o++) + { + if (*p == '\n') + { + o++; + *p = '\r'; + } + *o = *p; + } + *o = '\0'; + free(intext); + return outtext; +} + +static void +_win32_sel_obj_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED) +{ + Sel_Manager_Selection *sel = data; + if (sel->owner == obj) sel->owner = NULL; +} + +static void +_win32_sel_obj_del2(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED) +{ + Sel_Manager_Selection *sel = data; + if (sel->request_obj == obj) sel->request_obj = NULL; +} + +static Ecore_Win32_Window * +_win32_window_get(const Evas_Object *obj) +{ + Evas_Object *top; + Ecore_Win32_Window *win = NULL; + + if (elm_widget_is(obj)) + { + top = elm_widget_top_get(obj); + if (!top) + { + Evas_Object *par; + par = elm_widget_parent_widget_get(obj); + if (par) top = elm_widget_top_get(par); + } + if (top && (efl_isa(top, EFL_UI_WIN_CLASS))) + win = elm_win_win32_window_get(top); + } + + if (!win) + { + Ecore_Evas *ee; + Evas *evas; + const char *engine_name; + + evas = evas_object_evas_get(obj); + if (!evas) return NULL; + + ee = ecore_evas_ecore_evas_get(evas); + if (!ee) return NULL; + + engine_name = ecore_evas_engine_name_get(ee); + if (!strcmp(engine_name, ELM_BUFFER)) + { + ee = ecore_evas_buffer_ecore_evas_parent_get(ee); + if (!ee) return NULL; + win = ecore_evas_win32_window_get(ee); + } + else + { + if ((strcmp(engine_name, ELM_SOFTWARE_WIN32) == 0) || + (strcmp(engine_name, ELM_SOFTWARE_DDRAW) == 0)) + return ecore_evas_win32_window_get(ee); + } + } + + return win; +} + +static Eina_Future * +_win32_efl_sel_manager_selection_set(Efl_Selection_Manager_Data *pd, + Evas_Object *owner, + Efl_Selection_Type type, + Efl_Selection_Format format, + Eina_Slice data, + Ecore_Win32_Window *win, + unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + + if (type != EFL_SELECTION_TYPE_CLIPBOARD) + return NULL; + + if ((!data.mem) && (format != EFL_SELECTION_FORMAT_IMAGE)) + { + efl_selection_manager_selection_clear(pd->sel_man, owner, type, seat); + return NULL; + } + + seat_sel = _win32_sel_manager_seat_selection_init(pd, seat); + seat_sel->active_type = type; + sel = seat_sel->sel_list + type; + if (sel->owner != owner) + { + Eina_List *l, *l_next; + Sel_Manager_Selection_Lost *sel_lost; + + EINA_LIST_FOREACH_SAFE(seat_sel->sel_lost_list, l, l_next, sel_lost) + { + if ((sel_lost->request == sel->owner) && + (sel_lost->type == type)) + { + eina_promise_resolve(sel_lost->promise, eina_value_uint_init(sel_lost->type)); + seat_sel->sel_lost_list = eina_list_remove(seat_sel->sel_lost_list, sel_lost); + free(sel_lost); + } + } + + } + if (sel->owner) + evas_object_event_callback_del_full(sel->owner, EVAS_CALLBACK_DEL, + _win32_sel_obj_del, sel); + sel->active = EINA_TRUE; + sel->owner = owner; + sel->win = win; + if (sel->set) sel->set(win, sel->data.mem, sel->data.len); + sel->format = format; + + evas_object_event_callback_add + (sel->owner, EVAS_CALLBACK_DEL, _win32_sel_obj_del, sel); + + ELM_SAFE_FREE(sel->data.mem, free); + sel->data = eina_slice_dup(data); + if (!sel->data.mem) + { + efl_selection_manager_selection_clear(pd->sel_man, owner, type, seat_sel->seat); + return NULL; + } + + return _update_sel_lost_list(owner, type, seat_sel); +} + +static void +_win32_efl_sel_manager_selection_clear(Efl_Selection_Manager_Data *pd, + Evas_Object *owner, + Efl_Selection_Type type, + Sel_Manager_Seat_Selection *seat_sel) +{ + Sel_Manager_Selection *sel; + Ecore_Win32_Window *win; + + if (type != EFL_SELECTION_TYPE_CLIPBOARD) + return; + + sel = seat_sel->sel_list + type; + + /* No longer this selection: Consider it gone! */ + if ((!sel->active) || (sel->owner != owner)) + return; + + if (sel->owner) + evas_object_event_callback_del_full(sel->owner, EVAS_CALLBACK_DEL, + _win32_sel_obj_del, sel); + if (sel->request_obj) + evas_object_event_callback_del_full(sel->request_obj, EVAS_CALLBACK_DEL, + _win32_sel_obj_del2, sel); + sel->owner = NULL; + sel->request_obj = NULL; + sel->active = EINA_FALSE; + ELM_SAFE_FREE(sel->data.mem, free); + /* sel->clear(win); */ +} + +static Eina_Bool +_win32_efl_sel_manager_selection_get(const Efl_Object *request, + Efl_Selection_Manager_Data *pd, + Efl_Selection_Type type, Efl_Selection_Format format, + void *data_func_data, Efl_Selection_Data_Ready data_func, + Eina_Free_Cb data_func_free_cb, + Ecore_Win32_Window *win, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + void *data; + int size; + + if (type != EFL_SELECTION_TYPE_CLIPBOARD) + return; + + seat_sel = _sel_manager_seat_selection_init(pd, seat); + sel = seat_sel->sel_list + type; + + if (sel->request_obj) + evas_object_event_callback_del_full(sel->request_obj, EVAS_CALLBACK_DEL, + _win32_sel_obj_del2, sel); + sel->request_format = format; + sel->request_obj = (Evas_Object *)request; + sel->win = win; + sel->data_func_data = data_func_data; + sel->data_func = data_func; + sel->data_func_free_cb = data_func_free_cb; + sel->get(win, &data, &size); + + if (!data || (size <= 0)) + goto cb_add; + + if ((sel->format & EFL_SELECTION_FORMAT_MARKUP) || + (sel->format & EFL_SELECTION_FORMAT_HTML)) + { + char *str; + + str = (char *)malloc(size + 1); + if (str) + { + memcpy(str, data, size); + str[size] = '\0'; + data = _win32_text_n_to_rn(_elm_util_mkup_to_text(str)); + free(str); + if (data) + size = strlen(data); + else + size = 0; + } + else + { + free(data); + data = NULL; + } + } + + if (sel->data_func && data && (size > 0)) + { + Efl_Selection_Data sdata; + + sdata.pos.x = sdata.pos.y = 0; + sdata.format = EFL_SELECTION_FORMAT_TEXT; + sdata.data.mem = data; + sdata.data.len = size; + sdata.action = sel->action; + sel->data_func(sel->data_func_data, sel->request_obj, &sdata); + } + + if (data) + free(data); + + cb_add: + evas_object_event_callback_add + (sel->request_obj, EVAS_CALLBACK_DEL, _win32_sel_obj_del2, sel); + + return EINA_TRUE; +} + +#endif /* HAVE_ELEMENTARY_WIN32 */ + + +static int +_drop_item_container_cmp(const void *d1, const void *d2) +{ + const Item_Container_Drop_Info *di = d1; + return (((uintptr_t)di->obj) - ((uintptr_t)d2)); +} + +static Eina_Bool +_drop_item_container_del(Efl_Selection_Manager_Data *pd, Efl_Object *cont, Eina_Bool full) +{ + Item_Container_Drop_Info *di; + + di = eina_list_search_unsorted(pd->drop_cont_list, + _drop_item_container_cmp, cont); + if (di) + { + _all_drop_targets_cbs_del(pd, NULL, cont, NULL); + di->item_func_data = NULL; + di->item_func = NULL; + + if (full) + { + pd->drop_cont_list = eina_list_remove(pd->drop_cont_list, di); + free(di); + } + return EINA_TRUE; + } + + return EINA_FALSE; +} + +static inline Eina_List * +_anim_icons_make(Sel_Manager_Drag_Container *dc) +{ + Eina_List *list = NULL, *icon_list = NULL; + Evas_Object *obj; + + if (dc->icon_list_func) + { + ERR("calling icon_list_func"); + icon_list = dc->icon_list_func(dc->icon_list_func_data, dc->cont); + } + EINA_LIST_FREE(icon_list, obj) + { + ERR("one obj in icon_list"); + Anim_Icon *ai = calloc(1, sizeof(Anim_Icon)); + if (!ai) + { + ERR("Failed to allocate for icon!"); + continue; + } + + evas_object_geometry_get(obj, &ai->start.x, &ai->start.y, &ai->start.w, &ai->start.h); + evas_object_show(obj); + ai->obj = obj; + list = eina_list_append(list, ai); + } + ERR("made icon list"); + + return list; +} + +static void +_cont_obj_drag_done_cb(void *data, const Efl_Event *ev EINA_UNUSED) +{ + Sel_Manager_Drag_Container *dc = data; + elm_widget_scroll_freeze_pop(dc->cont); +} + +static Eina_Bool +_cont_obj_drag_start(void *data) +{ + ERR("going to start draging"); + Sel_Manager_Drag_Container *dc = data; + + dc->timer = NULL; + //efl_event_callback_add(dc->cont, EFL_UI_DND_EVENT_DRAG_DONE, _cont_obj_drag_done_cb, dc); + elm_widget_scroll_freeze_push(dc->cont); + efl_selection_manager_drag_start(dc->pd->sel_man, dc->cont, dc->format, + eina_rw_slice_slice_get(dc->data), dc->action, + dc->icon_func_data, dc->icon_func, dc->icon_func_free_cb, + dc->seat); + + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_drag_anim_play(void *data, double pos) +{ + Sel_Manager_Drag_Container *dc = data; + + ERR("In"); + if (dc->animator) + { + Eina_List *l; + Anim_Icon *ai; + Evas_Coord xm, ym; + + if (pos > 0.99) + { + dc->animator = NULL; + EINA_LIST_FOREACH(dc->icons, l, ai) + evas_object_hide(ai->obj); + + _cont_obj_drag_start(dc); + return ECORE_CALLBACK_CANCEL; + } + + evas_pointer_canvas_xy_get(dc->e, &xm, &ym); + EINA_LIST_FOREACH(dc->icons, l, ai) + { + int x, y, w, h; + w = ai->start.w - ((dc->final_icon.w - ai->start.w) * pos); + h = ai->start.h - ((dc->final_icon.h - ai->start.h) * pos); + x = ai->start.x - (pos * (ai->start.x + (w / 2) - xm)); + y = ai->start.y - (pos * (ai->start.y + (h / 2) - ym)); + evas_object_move(ai->obj, x, y); + evas_object_resize(ai->obj, w, h); + } + + return ECORE_CALLBACK_RENEW; + } + + return ECORE_CALLBACK_CANCEL; +} + +static inline void +_drag_anim_start(Sel_Manager_Drag_Container *dc) +{ + ERR("In"); + + dc->timer = NULL; + if (dc->icon_func) + { + Eina_Position2D pos_ret; + Evas_Object *temp_win = elm_win_add(NULL, "Temp", ELM_WIN_DND); + Evas_Object *final_icon = dc->icon_func(dc->icon_func_data, temp_win, dc->cont, &pos_ret); + evas_object_geometry_get(final_icon, NULL, NULL, &dc->final_icon.w, &dc->final_icon.h); + evas_object_del(final_icon); + evas_object_del(temp_win); + } + dc->animator = ecore_animator_timeline_add(dc->anim_duration, _drag_anim_play, dc); +} + +static Eina_Bool +_cont_obj_anim_start(void *data) +{ + sel_debug("In"); + Sel_Manager_Drag_Container *dc = data; + Efl_Object *it = NULL; + Eina_Position2D posret; //does not use + + if (dc->item_get_func) + it = dc->item_get_func(dc->item_get_func_data, dc->cont, dc->down, &posret); + dc->timer = NULL; + dc->format = EFL_SELECTION_FORMAT_TARGETS; //default + dc->data.len = 0; + dc->action = EFL_SELECTION_ACTION_COPY; //default + dc->icons = NULL; + + //failed to get mouse-down item, abort drag + if (!it) + return ECORE_CALLBACK_CANCEL; + + if (dc->drag_data_func) + { + dc->drag_data_func(dc->drag_data_func_data, dc->cont, + &dc->format, &dc->data, &dc->action); + if (EINA_DBL_EQ(dc->anim_duration, 0.0)) + { + _cont_obj_drag_start(dc); + } + else + { + dc->icons = _anim_icons_make(dc); + if (dc->icons) + { + _drag_anim_start(dc); + } + else + { + // even if we don't manage the icons animation, we have + // to wait until it is finished before beginning drag. + dc->timer = ecore_timer_add(dc->anim_duration, + _cont_obj_drag_start, dc); + } + } + } + + return ECORE_CALLBACK_CANCEL; +} + +static void +_abort_drag(Evas_Object *obj EINA_UNUSED, Sel_Manager_Drag_Container *dc) +{ + evas_object_event_callback_del_full(dc->cont, EVAS_CALLBACK_MOUSE_MOVE, + _cont_obj_mouse_move_cb, dc); + evas_object_event_callback_del_full(dc->cont, EVAS_CALLBACK_MOUSE_UP, + _cont_obj_mouse_up_cb, dc); + _item_container_del_internal(dc, EINA_FALSE); + + ELM_SAFE_FREE(dc->timer, ecore_timer_del); + _anim_data_free(dc); +} + +static void +_cont_obj_mouse_move_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info) +{ + Sel_Manager_Drag_Container *dc = dc; + Evas_Event_Mouse_Move *ev = event_info; + + if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) + { + _abort_drag(obj, dc); + } + if (dc && + (evas_device_class_get(ev->dev) == EVAS_DEVICE_CLASS_TOUCH)) + { + int dx, dy; + int fs = elm_config_finger_size_get(); + + dx = ev->cur.canvas.x - dc->down.x; + dy = ev->cur.canvas.y - dc->down.y; + if ((dx * dx + dy * dy) > (fs * fs)) + { + sel_debug("mouse moved too much - have to cancel DnD"); + _abort_drag(obj, dc); + } + } +} + +static void +_anim_data_free(Sel_Manager_Drag_Container *dc) +{ + if (dc) + { + ELM_SAFE_FREE(dc->animator, ecore_animator_del); + Anim_Icon *ai; + + EINA_LIST_FREE(dc->icons, ai) + { + evas_object_del(ai->obj); + free(ai); + } + dc->icons = NULL; + } +} + +static void +_cont_obj_mouse_up_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info) +{ + Sel_Manager_Drag_Container *dc = data; + + if (((Evas_Event_Mouse_Up *)event_info)->button != 1) + return; + + evas_object_event_callback_del_full(dc->cont, EVAS_CALLBACK_MOUSE_MOVE, + _cont_obj_mouse_move_cb, dc); + evas_object_event_callback_del_full(dc->cont, EVAS_CALLBACK_MOUSE_UP, + _cont_obj_mouse_up_cb, dc); + ELM_SAFE_FREE(dc->timer, ecore_timer_del); + + _anim_data_free(dc); +} + +static void +_cont_obj_mouse_down_cb(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info) +{ + Sel_Manager_Drag_Container *dc = data; + Evas_Event_Mouse_Down *ev = event_info; + if (ev->button != 1) + return; + + dc->e = e; + dc->down.x = ev->canvas.x; + dc->down.y = ev->canvas.y; + + evas_object_event_callback_add(dc->cont, EVAS_CALLBACK_MOUSE_UP, + _cont_obj_mouse_up_cb, dc); + ecore_timer_del(dc->timer); + if (dc->time_to_drag) + { + dc->timer = ecore_timer_add(dc->time_to_drag, _cont_obj_anim_start, dc); + evas_object_event_callback_add(dc->cont, EVAS_CALLBACK_MOUSE_MOVE, + _cont_obj_mouse_move_cb, dc); + } + else + { + _cont_obj_anim_start(dc); + } +} + +static void +_item_container_del_internal(Sel_Manager_Drag_Container *dc, Eina_Bool full) +{ + if (dc) + { + ELM_SAFE_FREE(dc->timer, ecore_timer_del); + if (dc->animator) + _anim_data_free(dc); + evas_object_event_callback_del_full(dc->cont, EVAS_CALLBACK_MOUSE_DOWN, + _cont_obj_mouse_down_cb, dc); + if (full) + { + dc->item_get_func = NULL; + dc->item_get_func_data = NULL; + free(dc); + } + } +} + +static int +_drag_item_container_cmp(const void *d1, const void *d2) +{ + const Sel_Manager_Drag_Container *dc = d1; + return (((uintptr_t)dc->cont) - ((uintptr_t)d2)); +} +//exposed APIs +EOLIAN static Eina_Future * +_efl_selection_manager_selection_set(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *owner, Efl_Selection_Type type, + Efl_Selection_Format format, + Eina_Slice data, unsigned int seat) +{ + Eina_Future *p = NULL; + + sel_debug("owner: %p, seat: %d, type: %d, format: %d", owner, seat, type, format); + if (type > EFL_SELECTION_TYPE_CLIPBOARD) + { + ERR("Not supported format: %d", type); + return NULL; + } + +#ifdef HAVE_ELEMENTARY_X + Ecore_X_Window xwin = _x11_xwin_get(owner); + if (xwin) + p = _x11_efl_sel_manager_selection_set(pd, owner, type, format, data, xwin, seat); +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Ecore_Wl2_Window *win = _wl_window_get(owner); + if (win) + p = _wl_efl_sel_manager_selection_set(pd, owner, type, format, data, win, seat); +#endif +#ifdef HAVE_ELEMENTARY_COCOA + Ecore_Cocoa_Window *win = _cocoa_window_get(owner); + if (win) + p = _cocoa_efl_sel_manager_selection_set(pd, owner, type, format, data, win, seat); +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + Ecore_Win32_Window *win = _win32_window_get(owner); + if (win) + p = _win32_efl_sel_manager_selection_set(pd, owner, type, format, data, win, seat); +#endif + + return p; +} + +//TODO: add support for local +EOLIAN static void +_efl_selection_manager_selection_get(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + const Efl_Object *request, Efl_Selection_Type type, + Efl_Selection_Format format, + void *data_func_data, Efl_Selection_Data_Ready data_func, + Eina_Free_Cb data_func_free_cb, unsigned int seat) +{ + sel_debug("request: %p, seat: %d, type: %d, format: %d", request, seat, type, format); +#ifdef HAVE_ELEMENTARY_X + Ecore_X_Window xwin = _x11_xwin_get(request); + if (xwin) + _x11_efl_sel_manager_selection_get(request, pd, type, format, data_func_data, + data_func, data_func_free_cb, xwin, seat); +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Ecore_Wl2_Window *win = _wl_window_get(request); + if (win) + _wl_efl_sel_manager_selection_get(request, pd, type, format, data_func_data, + data_func, data_func_free_cb, win, seat); +#endif +#ifdef HAVE_ELEMENTARY_COCOA + Ecore_Cocoa_Window *win = _cocoa_window_get(request); + if (win) + _cocoa_efl_sel_manager_selection_get(request, pd, type, format, data_func_data, + data_func, data_func_free_cb, win, seat); +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + Ecore_Win32_Window *win = _win32_window_get(request); + if (win) + _win32_efl_sel_manager_selection_get(request, pd, type, format, data_func_data, + data_func, data_func_free_cb, win, seat); +#endif +} + +EOLIAN static void +_efl_selection_manager_selection_clear(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *owner, Efl_Selection_Type type, unsigned int seat) +{ + Eina_Bool local = EINA_FALSE; + Sel_Manager_Seat_Selection *seat_sel; + Sel_Manager_Selection *sel; + + sel_debug("owner: %p, seat: %d, type: %d", owner, seat, type); + seat_sel = _sel_manager_seat_selection_init(pd, seat); +#ifdef HAVE_ELEMENTARY_X + sel = seat_sel->sel_list + type; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + sel = seat_sel->sel; +#endif +#ifdef HAVE_ELEMENTARY_COCOA + sel = seat_sel->sel; +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + sel = seat_sel->sel_list + type; +#endif + if ((!sel->active) && (sel->owner != owner)) + { + return; + } + sel->active = EINA_FALSE; +#ifdef HAVE_ELEMENTARY_X + seat_sel->sel_list[type].data.len = 0; + if (seat_sel->sel_list[type].data.mem) + { + free(seat_sel->sel_list[type].data.mem); + seat_sel->sel_list[type].data.mem = NULL; + } + if (sel->xwin != 0) + local = EINA_TRUE; + if (!local) + { + seat_sel->sel_list[type].clear(); + } + else + { + Eina_List *l, *l_next; + Sel_Manager_Selection_Lost *sel_lost; + + EINA_LIST_FOREACH_SAFE(seat_sel->sel_lost_list, l, l_next, sel_lost) + { + if ((sel_lost->request == sel->owner) && + (sel_lost->type == type)) + { + eina_promise_resolve(sel_lost->promise, eina_value_uint_init(sel_lost->type)); + seat_sel->sel_lost_list = eina_list_remove(seat_sel->sel_lost_list, sel_lost); + free(sel_lost); + } + } + seat_sel->sel_list[type].owner = NULL; + } +#endif +#ifdef HAVE_ELEMENTARY_WL2 + sel->selection_serial = ecore_wl2_dnd_selection_clear(_wl_seat_get(_wl_window_get(owner), owner, seat)); +#endif +#ifdef HAVE_ELEMENTARY_COCOA + if (sel->owner) + evas_object_event_callback_del_full(sel->owner, EVAS_CALLBACK_DEL, + _cocoa_sel_obj_del_cb, sel); + if (sel->request_obj) + evas_object_event_callback_del_full(sel->request_obj, EVAS_CALLBACK_DEL, + _cocoa_sel_obj_del_req_cb, sel); + sel->owner = NULL; + sel->request_obj = NULL; + ELM_SAFE_FREE(sel->data.mem, free); + sel->data.len = 0; + + ecore_cocoa_clipboard_clear(); +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + _win32_efl_sel_manager_selection_clear(pd, owner, type, seat_sel); +#endif +} + +EOLIAN static Eina_Bool +_efl_selection_manager_selection_has_owner(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd EINA_UNUSED, + Efl_Object *request, Efl_Selection_Type type, + unsigned int seat) +{ +#ifdef HAVE_ELEMENTARY_X + (void)seat; + if (_x11_xwin_get(request)) + { + Ecore_X_Atom xtype; + switch (type) + { + case EFL_SELECTION_TYPE_PRIMARY: + xtype = ECORE_X_ATOM_SELECTION_PRIMARY; + break; + case EFL_SELECTION_TYPE_SECONDARY: + xtype = ECORE_X_ATOM_SELECTION_SECONDARY; + break; + case EFL_SELECTION_TYPE_DND: + xtype = ECORE_X_ATOM_SELECTION_XDND; + break; + default: + xtype = ECORE_X_ATOM_SELECTION_CLIPBOARD; + } + return !!ecore_x_selection_owner_get(xtype); + } +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Ecore_Wl2_Window *win; + + win = _wl_window_get(request); + if (win) + return !!ecore_wl2_dnd_selection_get(_wl_seat_get(win, request, seat)); +#endif + return EINA_FALSE; +} + +EOLIAN static void +_efl_selection_manager_drag_start(Eo *obj, Efl_Selection_Manager_Data *pd, + Efl_Object *drag_obj, Efl_Selection_Format format, + Eina_Slice data, Efl_Selection_Action action, + void *icon_func_data, Efl_Dnd_Drag_Icon_Create icon_func, + Eina_Free_Cb icon_func_free_cb, unsigned int seat) +{ +#ifdef HAVE_ELEMENTARY_X + Ecore_X_Window xwin = _x11_xwin_get(drag_obj); + if (xwin) + _x11_efl_sel_manager_drag_start(obj, pd, drag_obj, format, data, action, + icon_func_data, icon_func, icon_func_free_cb, + xwin, seat); +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Ecore_Wl2_Window *win = _wl_window_get(drag_obj); + if (win) + _wl_efl_sel_manager_drag_start(obj, pd, drag_obj, format, data, action, + icon_func_data, icon_func, icon_func_free_cb, + win, seat); +#endif +#ifdef HAVE_ELEMENTARY_WIN32 +#endif +#ifdef HAVE_ELEMENTARY_COCOA +#endif +} + +EOLIAN static void +_efl_selection_manager_drag_cancel(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *drag_obj, unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel = _sel_manager_seat_selection_init(pd, seat); + +#ifdef HAVE_ELEMENTARY_X + Ecore_X_Window xwin = _x11_xwin_get(drag_obj); + if (xwin) + { + ecore_x_pointer_ungrab(); + ELM_SAFE_FREE(seat_sel->mouse_up_handler, ecore_event_handler_del); + ELM_SAFE_FREE(seat_sel->dnd_status_handler, ecore_event_handler_del); + ecore_x_dnd_abort(xwin); + if (seat_sel->drag_obj) + { + if (elm_widget_is(seat_sel->drag_obj)) + { + Evas_Object *win = elm_widget_top_get(seat_sel->drag_obj); + if (win && efl_isa(win, EFL_UI_WIN_CLASS)) + efl_event_callback_del(win, EFL_UI_WIN_EVENT_ROTATION_CHANGED, + _x11_win_rotation_changed_cb, seat_sel->drag_win); + } + } + seat_sel->drag_obj = NULL; + } +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Ecore_Wl2_Window *win; + + win = _wl_window_get(drag_obj); + if (win) + ecore_wl2_dnd_drag_end(_wl_seat_get(win, drag_obj, seat)); +#endif + + ELM_SAFE_FREE(seat_sel->drag_win, evas_object_del); +} + +EOLIAN static void +_efl_selection_manager_drag_action_set(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *drag_obj, Efl_Selection_Action action, + unsigned int seat) +{ + Sel_Manager_Seat_Selection *seat_sel = _sel_manager_seat_selection_init(pd, seat); + if (seat_sel->drag_action == action) return; + seat_sel->drag_action = action; +#ifdef HAVE_ELEMENTARY_X + Ecore_X_Atom actx; + Ecore_X_Window xwin = _x11_xwin_get(drag_obj); + if (xwin) + { + actx = _x11_dnd_action_rev_map(action); + ecore_x_dnd_source_action_set(actx); + } +#endif +} + +//drop side +EOLIAN static Eina_Bool +_efl_selection_manager_drop_target_add(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *target_obj, Efl_Selection_Format format, + unsigned int seat) +{ + Eina_Bool ret = EINA_FALSE; +#ifdef HAVE_ELEMENTARY_X + Ecore_X_Window xwin = _x11_xwin_get(target_obj); + if (xwin) + ret = _x11_sel_manager_drop_target_add(pd, target_obj, format, xwin, seat); +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Ecore_Wl2_Window *win = _wl_window_get(target_obj); + if (win) + ret = _wl_sel_manager_drop_target_add(pd, target_obj, format, seat); +#endif + return ret; +} + +EOLIAN static void +_efl_selection_manager_drop_target_del(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *target_obj, Efl_Selection_Format format, + unsigned int seat) +{ + Sel_Manager_Dropable *dropable = NULL; + Sel_Manager_Seat_Selection *seat_sel; + + dropable = efl_key_data_get(target_obj, "__elm_dropable"); + if (dropable) + { + Eina_Inlist *itr; + Drop_Format *df; + EINA_INLIST_FOREACH_SAFE(dropable->format_list, itr, df) + { + if (df->format == format) + { + dropable->format_list = eina_inlist_remove(dropable->format_list, + EINA_INLIST_GET(df)); + free(df); + } + } + if (!dropable->format_list) + { + pd->drop_list = eina_list_remove(pd->drop_list, dropable); + efl_key_data_set(target_obj, "__elm_dropable", NULL); + free(dropable); + evas_object_event_callback_del(target_obj, EVAS_CALLBACK_DEL, + _all_drop_targets_cbs_del); + } + } + + if (!pd->drop_list) return; +#ifdef HAVE_ELEMENTARY_X + Eina_List *l; + Ecore_X_Window xwin; + Eina_Bool have_drop_list = EINA_FALSE; + + xwin = _x11_xwin_get(target_obj); + EINA_LIST_FOREACH(pd->drop_list, l, dropable) + { + if (xwin == _x11_xwin_get(dropable->obj)) + { + have_drop_list = EINA_TRUE; + break; + } + } + if (!have_drop_list) ecore_x_dnd_aware_set(xwin, EINA_FALSE); +#endif + seat_sel = _sel_manager_seat_selection_init(pd, seat); + ELM_SAFE_FREE(seat_sel->pos_handler, ecore_event_handler_del); + ELM_SAFE_FREE(seat_sel->drop_handler, ecore_event_handler_del); + ELM_SAFE_FREE(seat_sel->enter_handler, ecore_event_handler_del); + ELM_SAFE_FREE(seat_sel->leave_handler, ecore_event_handler_del); +} + +EOLIAN static void +_efl_selection_manager_container_drop_item_add(Eo *obj, Efl_Selection_Manager_Data *pd, + Efl_Object *cont, Efl_Selection_Format format, + void *item_func_data, Efl_Dnd_Item_Get item_func, + Eina_Free_Cb item_func_free_cb EINA_UNUSED, + unsigned int seat) +{ + Item_Container_Drop_Info *di; + Sel_Manager_Dropable *dropable = NULL; + + if (_drop_item_container_del(pd, cont, EINA_FALSE)) + { + di = eina_list_search_unsorted(pd->drop_cont_list, _drop_item_container_cmp, obj); + if (!di) return; + } + else + { + di = calloc(1, sizeof(Item_Container_Drop_Info)); + if (!di) return; + + di->obj = obj; + pd->drop_cont_list = eina_list_append(pd->drop_cont_list, di); + } + di->item_func = item_func; + di->item_func_data = item_func_data; + + dropable = efl_key_data_get(cont, "__elm_dropable"); + if (!dropable) + { + dropable = calloc(1, sizeof(Sel_Manager_Dropable)); + if (!dropable) return; + dropable->last.in = EINA_FALSE; + pd->drop_list = eina_list_append(pd->drop_list, dropable); + if (!pd->drop_list) return; + dropable->obj = cont; + efl_key_data_set(cont, "__elm_dropable", dropable); + } + dropable->is_container = EINA_TRUE; + dropable->item_func = item_func; + dropable->item_func_data = item_func_data; + _efl_selection_manager_drop_target_add(obj, pd, cont, format, seat); +} + +EOLIAN static void +_efl_selection_manager_container_drop_item_del(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *cont, unsigned int seat EINA_UNUSED) +{ + ERR("In"); + _drop_item_container_del(pd, cont, EINA_TRUE); +} + +EOLIAN static void +_efl_selection_manager_container_drag_item_add(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *cont, double time_to_drag, double anim_duration, + void *data_func_data, Efl_Dnd_Drag_Data_Get data_func, Eina_Free_Cb data_func_free_cb, + void *item_get_func_data, Efl_Dnd_Item_Get item_get_func, Eina_Free_Cb item_get_func_free_cb, + void *icon_func_data, Efl_Dnd_Drag_Icon_Create icon_func, Eina_Free_Cb icon_func_free_cb, + void *icon_list_func_data, Efl_Dnd_Drag_Icon_List_Create icon_list_func, Eina_Free_Cb icon_list_func_free_cb, + unsigned int seat) +{ + //TODO: remove previous drag one + Sel_Manager_Drag_Container *dc = calloc(1, sizeof(Sel_Manager_Drag_Container)); + if (!dc) + { + ERR("Failed to allocate memory"); + return; + } + dc->cont = cont; + dc->time_to_drag = time_to_drag; + dc->anim_duration = anim_duration; + dc->drag_data_func_data = data_func_data; + dc->drag_data_func = data_func; + dc->drag_data_func_free_cb = data_func_free_cb; + dc->item_get_func_data = item_get_func_data; + dc->item_get_func = item_get_func; + dc->item_get_func_free_cb = item_get_func_free_cb; + dc->icon_func_data = icon_func_data; + dc->icon_func = icon_func; + dc->icon_func_free_cb = icon_func_free_cb; + dc->icon_list_func_data = icon_list_func_data; + dc->icon_list_func = icon_list_func; + dc->icon_list_func_free_cb = icon_list_func_free_cb; + dc->seat = seat; + dc->pd = pd; + + _sel_manager_seat_selection_init(pd, seat); + + pd->drag_cont_list = eina_list_append(pd->drag_cont_list, dc); + + evas_object_event_callback_add(cont, EVAS_CALLBACK_MOUSE_DOWN, + _cont_obj_mouse_down_cb, dc); +} + +EOLIAN static void +_efl_selection_manager_container_drag_item_del(Eo *obj EINA_UNUSED, Efl_Selection_Manager_Data *pd, + Efl_Object *cont, unsigned int seat EINA_UNUSED) +{ + Sel_Manager_Drag_Container *dc = eina_list_search_unsorted(pd->drag_cont_list, + _drag_item_container_cmp, cont); + if (dc) + _item_container_del_internal(dc, EINA_TRUE); +} + +static Eo * +_efl_selection_manager_efl_object_constructor(Eo *obj, Efl_Selection_Manager_Data *pd) +{ + obj = efl_constructor(efl_super(obj, MY_CLASS)); + + pd->sel_man = obj; + pd->atom_list = calloc(1, SELECTION_N_ATOMS * sizeof(Sel_Manager_Atom)); + if (!pd->atom_list) + { + ERR("failed to allocate atom_list"); + return NULL; + } + pd->atom_list[SELECTION_ATOM_TARGETS].name = "TARGETS"; + pd->atom_list[SELECTION_ATOM_TARGETS].format = EFL_SELECTION_FORMAT_TARGETS; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_TARGETS].x_converter = _x11_targets_converter; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_TARGETS].wl_converter = _wl_targets_converter; +#endif + pd->atom_list[SELECTION_ATOM_ATOM].name = "ATOM"; // for opera browser + pd->atom_list[SELECTION_ATOM_ATOM].format = EFL_SELECTION_FORMAT_TARGETS; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_ATOM].x_converter = _x11_targets_converter; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_ATOM].wl_converter = _wl_targets_converter; +#endif + + pd->atom_list[SELECTION_ATOM_ELM].name = "application/x-elementary-markup"; + pd->atom_list[SELECTION_ATOM_ELM].format = EFL_SELECTION_FORMAT_MARKUP; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_ELM].x_converter = _x11_general_converter; + pd->atom_list[SELECTION_ATOM_ELM].x_data_preparer = _x11_data_preparer_markup; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_ELM].wl_converter = _wl_general_converter; + pd->atom_list[SELECTION_ATOM_ELM].wl_data_preparer = _wl_data_preparer_markup; +#endif + + pd->atom_list[SELECTION_ATOM_TEXT_URILIST].name = "text/uri-list"; + pd->atom_list[SELECTION_ATOM_TEXT_URILIST].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_TEXT_URILIST].x_converter = _x11_general_converter; + pd->atom_list[SELECTION_ATOM_TEXT_URILIST].x_data_preparer = _x11_data_preparer_uri; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_TEXT_URILIST].wl_converter = _wl_general_converter; + pd->atom_list[SELECTION_ATOM_TEXT_URILIST].wl_data_preparer = _wl_data_preparer_uri; +#endif + + pd->atom_list[SELECTION_ATOM_TEXT_X_VCARD].name = "text/x-vcard"; + pd->atom_list[SELECTION_ATOM_TEXT_X_VCARD].format = EFL_SELECTION_FORMAT_VCARD; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_TEXT_X_VCARD].x_converter = _x11_vcard_send; + pd->atom_list[SELECTION_ATOM_TEXT_X_VCARD].x_data_preparer = _x11_data_preparer_vcard; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_TEXT_X_VCARD].wl_data_preparer = _wl_data_preparer_vcard; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_PNG].name = "image/png"; + pd->atom_list[SELECTION_ATOM_IMAGE_PNG].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_PNG].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_PNG].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_PNG].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_JPEG].name = "image/jpeg"; + pd->atom_list[SELECTION_ATOM_IMAGE_JPEG].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_JPEG].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_JPEG].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_JPEG].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_BMP].name = "image/x-ms-bmp"; + pd->atom_list[SELECTION_ATOM_IMAGE_BMP].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_BMP].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_BMP].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_BMP].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_GIF].name = "image/gif"; + pd->atom_list[SELECTION_ATOM_IMAGE_GIF].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_GIF].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_GIF].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_GIF].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_TIFF].name = "image/tiff"; + pd->atom_list[SELECTION_ATOM_IMAGE_TIFF].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_TIFF].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_TIFF].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_TIFF].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_SVG].name = "image/svg+xml"; + pd->atom_list[SELECTION_ATOM_IMAGE_SVG].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_SVG].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_SVG].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_SVG].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_XPM].name = "image/x-xpixmap"; + pd->atom_list[SELECTION_ATOM_IMAGE_XPM].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_XPM].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_XPM].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_XPM].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_TGA].name = "image/x-tga"; + pd->atom_list[SELECTION_ATOM_IMAGE_TGA].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_TGA].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_TGA].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_TGA].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_IMAGE_PPM].name = "image/x-portable-pixmap"; + pd->atom_list[SELECTION_ATOM_IMAGE_PPM].format = EFL_SELECTION_FORMAT_IMAGE; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_IMAGE_PPM].x_converter = _x11_image_converter; + pd->atom_list[SELECTION_ATOM_IMAGE_PPM].x_data_preparer = _x11_data_preparer_image; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_IMAGE_PPM].wl_data_preparer = _wl_data_preparer_image; +#endif + + pd->atom_list[SELECTION_ATOM_UTF8STRING].name = "UTF8_STRING"; + pd->atom_list[SELECTION_ATOM_UTF8STRING].format = EFL_SELECTION_FORMAT_TEXT | EFL_SELECTION_FORMAT_MARKUP | EFL_SELECTION_FORMAT_HTML; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_UTF8STRING].x_converter = _x11_text_converter; + pd->atom_list[SELECTION_ATOM_UTF8STRING].x_data_preparer = _x11_data_preparer_text; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_UTF8STRING].wl_converter = _wl_text_converter; + pd->atom_list[SELECTION_ATOM_UTF8STRING].wl_data_preparer = _wl_data_preparer_text, +#endif + + pd->atom_list[SELECTION_ATOM_STRING].name = "STRING"; + pd->atom_list[SELECTION_ATOM_STRING].format = EFL_SELECTION_FORMAT_TEXT | EFL_SELECTION_FORMAT_MARKUP | EFL_SELECTION_FORMAT_HTML; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_STRING].x_converter = _x11_text_converter; + pd->atom_list[SELECTION_ATOM_STRING].x_data_preparer = _x11_data_preparer_text; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_STRING].wl_converter = _wl_text_converter; + pd->atom_list[SELECTION_ATOM_STRING].wl_data_preparer = _wl_data_preparer_text; +#endif + + pd->atom_list[SELECTION_ATOM_COMPOUND_TEXT].name = "COMPOUND_TEXT"; + pd->atom_list[SELECTION_ATOM_COMPOUND_TEXT].format = EFL_SELECTION_FORMAT_TEXT | EFL_SELECTION_FORMAT_MARKUP | EFL_SELECTION_FORMAT_HTML; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_COMPOUND_TEXT].x_converter = _x11_text_converter; + pd->atom_list[SELECTION_ATOM_COMPOUND_TEXT].x_data_preparer = _x11_data_preparer_text; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_COMPOUND_TEXT].wl_converter = _wl_text_converter; + pd->atom_list[SELECTION_ATOM_COMPOUND_TEXT].wl_data_preparer = _wl_data_preparer_text; +#endif + + pd->atom_list[SELECTION_ATOM_TEXT].name = "TEXT"; + pd->atom_list[SELECTION_ATOM_TEXT].format = EFL_SELECTION_FORMAT_TEXT | EFL_SELECTION_FORMAT_MARKUP | EFL_SELECTION_FORMAT_HTML; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_TEXT].x_converter = _x11_text_converter; + pd->atom_list[SELECTION_ATOM_TEXT].x_data_preparer = _x11_data_preparer_text; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_TEXT].wl_converter = _wl_text_converter; + pd->atom_list[SELECTION_ATOM_TEXT].wl_data_preparer = _wl_data_preparer_text; +#endif + + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN_UTF8].name = "text/plain;charset=utf-8"; + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN_UTF8].format = EFL_SELECTION_FORMAT_TEXT | EFL_SELECTION_FORMAT_MARKUP | EFL_SELECTION_FORMAT_HTML; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN_UTF8].x_converter = _x11_text_converter; + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN_UTF8].x_data_preparer = _x11_data_preparer_text; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN_UTF8].wl_converter = _wl_text_converter; + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN_UTF8].wl_data_preparer = _wl_data_preparer_text; +#endif + + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN].name = "text/plain"; + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN].format = EFL_SELECTION_FORMAT_TEXT | EFL_SELECTION_FORMAT_MARKUP | EFL_SELECTION_FORMAT_HTML; +#ifdef HAVE_ELEMENTARY_X + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN].x_converter = _x11_text_converter; + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN].x_data_preparer = _x11_data_preparer_text; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN].wl_converter = _wl_text_converter; + pd->atom_list[SELECTION_ATOM_TEXT_PLAIN].wl_data_preparer = _wl_data_preparer_text; +#endif + + + int i; +#ifdef HAVE_ELEMENTARY_X + for (i = 0; i < SELECTION_N_ATOMS; i++) + { + pd->atom_list[i].x_atom = ecore_x_atom_get(pd->atom_list[i].name); + ecore_x_selection_converter_atom_add + (pd->atom_list[i].x_atom, pd->atom_list[i].x_converter); + } + pd->notify_handler = ecore_event_handler_add(ECORE_X_EVENT_SELECTION_NOTIFY, + _efl_sel_manager_x11_selection_notify, pd); + pd->clear_handler = ecore_event_handler_add(ECORE_X_EVENT_SELECTION_CLEAR, + _x11_selection_clear, pd); + pd->fix_handler = ecore_event_handler_add(ECORE_X_EVENT_FIXES_SELECTION_NOTIFY, + _x11_fixes_selection_notify, pd); +#endif + + pd->type_hash = eina_hash_string_small_new(NULL); + for (i = 0; i < SELECTION_N_ATOMS; i++) + { + eina_hash_add(pd->type_hash, pd->atom_list[i].name, &pd->atom_list[i]); + } + pd->text_uri = eina_stringshare_add("text/uri-list"); + +#ifdef HAVE_ELEMENTARY_WL2 + pd->send_handler = ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_SEND, + _wl_selection_send, pd); + pd->changed_handler = ecore_event_handler_add(ECORE_WL2_EVENT_SEAT_SELECTION, + _wl_selection_changed, pd); + pd->end_handler = ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_END, + _wl_dnd_end, pd); +#endif + return obj; +} + +static void +_efl_selection_manager_efl_object_destructor(Eo *obj, Efl_Selection_Manager_Data *pd) +{ + Sel_Manager_Seat_Selection *seat_sel; + +#ifdef HAVE_ELEMENTARY_X + ecore_event_handler_del(pd->notify_handler); + ecore_event_handler_del(pd->clear_handler); +#endif +#ifdef HAVE_ELEMENTARY_WL2 + ecore_event_handler_del(pd->send_handler); + ecore_event_handler_del(pd->changed_handler); + ecore_event_handler_del(pd->end_handler); +#endif + free(pd->atom_list); + EINA_LIST_FREE(pd->seat_list, seat_sel) + { + ecore_event_handler_del(seat_sel->pos_handler); + ecore_event_handler_del(seat_sel->drop_handler); + ecore_event_handler_del(seat_sel->enter_handler); + ecore_event_handler_del(seat_sel->leave_handler); +#ifdef HAVE_ELEMENTARY_X + free(seat_sel->sel_list); +#endif +#ifdef HAVE_ELEMENTARY_WL2 + free(seat_sel->sel); +#endif +#ifdef HAVE_ELEMENTARY_COCOA + free(seat_sel->sel); +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + free(seat_sel->sel_list); +#endif + free(seat_sel->saved_types->types); + free(seat_sel->saved_types->imgfile); + free(seat_sel->saved_types); + } + eina_hash_free(pd->type_hash); + eina_stringshare_del(pd->text_uri); + + efl_destructor(efl_super(obj, MY_CLASS)); +} + +#ifdef HAVE_ELEMENTARY_X +static void +_set_selection_list(Sel_Manager_Selection *sel_list, Sel_Manager_Seat_Selection *seat_sel) +{ + sel_list[EFL_SELECTION_TYPE_PRIMARY].debug = "Primary"; + sel_list[EFL_SELECTION_TYPE_PRIMARY].ecore_sel = ECORE_X_SELECTION_PRIMARY; + sel_list[EFL_SELECTION_TYPE_PRIMARY].set = ecore_x_selection_primary_set; + sel_list[EFL_SELECTION_TYPE_PRIMARY].clear = ecore_x_selection_primary_clear; + sel_list[EFL_SELECTION_TYPE_PRIMARY].request = ecore_x_selection_primary_request; + sel_list[EFL_SELECTION_TYPE_PRIMARY].seat_sel = seat_sel; + + sel_list[EFL_SELECTION_TYPE_SECONDARY].debug = "Secondary"; + sel_list[EFL_SELECTION_TYPE_SECONDARY].ecore_sel = ECORE_X_SELECTION_SECONDARY; + sel_list[EFL_SELECTION_TYPE_SECONDARY].set = ecore_x_selection_secondary_set; + sel_list[EFL_SELECTION_TYPE_SECONDARY].clear = ecore_x_selection_secondary_clear; + sel_list[EFL_SELECTION_TYPE_SECONDARY].request = ecore_x_selection_secondary_request; + sel_list[EFL_SELECTION_TYPE_SECONDARY].seat_sel = seat_sel; + + sel_list[EFL_SELECTION_TYPE_DND].debug = "DnD"; + sel_list[EFL_SELECTION_TYPE_DND].ecore_sel = ECORE_X_SELECTION_PRIMARY; + sel_list[EFL_SELECTION_TYPE_DND].request = ecore_x_selection_xdnd_request; + sel_list[EFL_SELECTION_TYPE_DND].seat_sel = seat_sel; + + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].debug = "Clipboard"; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].ecore_sel = ECORE_X_SELECTION_CLIPBOARD; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].set = ecore_x_selection_clipboard_set; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].clear = ecore_x_selection_clipboard_clear; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].request = ecore_x_selection_clipboard_request; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].seat_sel = seat_sel; +} +#endif +#ifdef HAVE_ELEMENTARY_WIN32 +static void +_set_selection_list(Sel_Manager_Selection *sel_list, Sel_Manager_Seat_Selection *seat_sel) +{ + sel_list[EFL_SELECTION_TYPE_PRIMARY].debug = "Primary"; + sel_list[EFL_SELECTION_TYPE_PRIMARY].ecore_sel = ECORE_WIN32_SELECTION_PRIMARY; + sel_list[EFL_SELECTION_TYPE_PRIMARY].set = ecore_win32_clipboard_set; + sel_list[EFL_SELECTION_TYPE_PRIMARY].clear = ecore_win32_clipboard_clear; + sel_list[EFL_SELECTION_TYPE_PRIMARY].get = ecore_win32_clipboard_get; + sel_list[EFL_SELECTION_TYPE_PRIMARY].seat_sel = seat_sel; + + sel_list[EFL_SELECTION_TYPE_SECONDARY].debug = "Secondary"; + sel_list[EFL_SELECTION_TYPE_SECONDARY].ecore_sel = ECORE_WIN32_SELECTION_OTHER; + sel_list[EFL_SELECTION_TYPE_SECONDARY].seat_sel = seat_sel; + + sel_list[EFL_SELECTION_TYPE_DND].debug = "DnD"; + sel_list[EFL_SELECTION_TYPE_DND].ecore_sel = ECORE_WIN32_SELECTION_OTHER; + sel_list[EFL_SELECTION_TYPE_DND].seat_sel = seat_sel; + + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].debug = "Clipboard"; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].ecore_sel = ECORE_WIN32_SELECTION_CLIPBOARD; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].set = ecore_win32_clipboard_set; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].clear = ecore_win32_clipboard_clear; + sel_list[EFL_SELECTION_TYPE_CLIPBOARD].seat_sel = seat_sel; +} +#endif + +#include "efl_selection_manager.eo.c" diff --git a/src/lib/elementary/efl_selection_manager.eo b/src/lib/elementary/efl_selection_manager.eo new file mode 100644 index 0000000000..5c4c6d9d16 --- /dev/null +++ b/src/lib/elementary/efl_selection_manager.eo @@ -0,0 +1,139 @@ +import efl_ui_dnd_types; + +class Efl.Selection.Manager (Efl.Object) { + methods { + selection_set @beta { + [[Set selection]] + params { + @in owner: Efl.Object; [[Seleciton owner]] + @in type: Efl.Selection.Type; [[Selection type]] + @in format: Efl.Selection.Format; [[Selection format]] + @in data: Eina.Slice; [[Selection data]] + @in seat: uint @optional;[[Specified seat for multiple seats case.]] + } + return: ptr(Eina.Future); [[Future for tracking when the selection is lost]] + } + selection_get @beta { + [[Get selection]] + params { + @in request: const(Efl.Object); [[Seleciton owner]] + @in type: Efl.Selection.Type; [[Selection type]] + @in format: Efl.Selection.Format; [[Selection Format]] + @in data_func: Efl.Selection.Data_Ready; [[Data ready function pointer]] + @in seat: uint @optional;[[Specified seat for multiple seats case.]] + } + } + selection_clear @beta { + params { + @in owner: Efl.Object; [[Seleciton owner]] + @in type: Efl.Selection.Type; [[Selection type]] + @in seat: uint @optional; [[Specified seat for multiple seats case.]] + } + } + selection_has_owner @beta { + [[Check if the request object has selection or not]] + params { + @in request: Efl.Object; [[Request object]] + @in type: Efl.Selection.Type; [[Selection type]] + @in seat: uint @optional; [[Specified seat for multiple seats case.]] + } + return: bool; [[EINA_TRUE if the request object has selection, otherwise, EINA_FALSE]] + } + drag_start @beta { + [[This starts a drag and drop process at the drag side. + During dragging, there are three events emitted as belows: + - EFL_UI_DND_EVENT_DRAG_POS + - EFL_UI_DND_EVENT_DRAG_ACCEPT + - EFL_UI_DND_EVENT_DRAG_DONE + ]] + params { + @in drag_obj: Efl.Object; [[Drag object]] + @in format: Efl.Selection.Format; [[Data format]] + @in data: Eina.Slice; [[Data to transfer]] + @in action: Efl.Selection.Action; [[Action when data is transferred]] + @in icon_func: Efl.Dnd.Drag_Icon_Create; [[Function pointer to create icon]] + @in seat: uint; [[Specified seat for multiple seats case.]] + } + } + drag_action_set @beta { + [[This sets the action for the drag]] + params { + @in drag_obj: Efl.Object; [[Drag object]] + @in action: Efl.Selection.Action; [[Drag action]] + @in seat: uint; [[Specified seat for multiple seats case.]] + } + } + drag_cancel @beta { + [[This cancels the on-going drag]] + params { + @in drag_obj: Efl.Object; [[Drag object]] + @in seat: uint; [[Specified seat for multiple seats case.]] + } + } + container_drag_item_add @beta { + [[This registers a drag for items in a container. Many items can be + dragged at a time. During dragging, there are three events emitted: + - EFL_UI_DND_EVENT_DRAG_POS + - EFL_UI_DND_EVENT_DRAG_ACCEPT + - EFL_UI_DND_EVENT_DRAG_DONE.]] + params { + @in cont: Efl.Object; [[Container object]] + @in time_to_drag: double; [[Time since mouse down happens to drag starts]] + @in anim_duration: double; [[animation duration]] + @in data_func: Efl.Dnd.Drag_Data_Get; [[Data and its format]] + @in item_func: Efl.Dnd.Item_Get; [[Item to determine drag start]] + @in icon_func: Efl.Dnd.Drag_Icon_Create; [[Icon used during drag]] + @in icon_list_func: Efl.Dnd.Drag_Icon_List_Create; [[Icons used for animations]] + @in seat: uint; [[Specified seat for multiple seats case]] + } + } + container_drag_item_del @beta { + [[Remove drag function of items in the container object.]] + params { + @in cont: Efl.Object; [[Container object]] + @in seat: uint; [[Specified seat for multiple seats case]] + } + } + drop_target_add @beta { + [[Add a dropable target. There are four events emitted: + - EFL_UI_DND_DROP_DRAG_ENTER + - EFL_UI_DND_DROP_DRAG_LEAVE + - EFL_UI_DND_DROP_DRAG_POS + - EFL_UI_DND_DROP_DRAG_DROP.]] + params { + @in target_obj: Efl.Object; [[Drop target]] + @in format: Efl.Selection.Format; [[Accepted data format]] + @in seat: uint; [[Specified seat for multiple seats case.]] + } + return: bool; [[$true on success, $false otherwise]] + } + drop_target_del @beta { + [[Remove a dropable target]] + params { + @in target_obj: Efl.Object; [[Drop target]] + @in format: Efl.Selection.Format; [[Accepted data format]] + @in seat: uint; [[Specified seat for multiple seats case.]] + } + } + container_drop_item_add @beta { + [[Add dropable target for a container in which items can drop to it]] + params { + @in cont: Efl.Object; [[Container object]] + @in format: Efl.Selection.Format; [[Accepted data formats]] + @in item_func: Efl.Dnd.Item_Get; [[Get item at specific position]] + @in seat: uint; [[Specified seat for multiple seats case.]] + } + } + container_drop_item_del @beta { + [[Remove dropable target for the container]] + params { + @in cont: Efl.Object; [[Container object]] + @in seat: uint; [[Specified seat for multiple seats case.]] + } + } + } + implements { + Efl.Object.constructor; + Efl.Object.destructor; + } +} diff --git a/src/lib/elementary/efl_selection_manager_private.h b/src/lib/elementary/efl_selection_manager_private.h new file mode 100644 index 0000000000..8ffa7c8df3 --- /dev/null +++ b/src/lib/elementary/efl_selection_manager_private.h @@ -0,0 +1,319 @@ +#ifndef EFL_SELECTION_MANAGER_PRIVATE_H +#define EFL_SELECTION_MANAGER_PRIVATE_H + +#ifdef HAVE_CONFIG_H +# include "elementary_config.h" +#endif + +#include +#include "elm_priv.h" + +enum +{ + SELECTION_ATOM_TARGETS = 0, + SELECTION_ATOM_ATOM, + SELECTION_ATOM_LISTING_ATOMS = SELECTION_ATOM_ATOM, + SELECTION_ATOM_TEXT_URILIST, + SELECTION_ATOM_TEXT_X_VCARD, + SELECTION_ATOM_IMAGE_PNG, + SELECTION_ATOM_IMAGE_JPEG, + SELECTION_ATOM_IMAGE_BMP, + SELECTION_ATOM_IMAGE_GIF, + SELECTION_ATOM_IMAGE_TIFF, + SELECTION_ATOM_IMAGE_SVG, + SELECTION_ATOM_IMAGE_XPM, + SELECTION_ATOM_IMAGE_TGA, + SELECTION_ATOM_IMAGE_PPM, + SELECTION_ATOM_ELM, + SELECTION_ATOM_UTF8STRING, + SELECTION_ATOM_STRING, + SELECTION_ATOM_COMPOUND_TEXT, + SELECTION_ATOM_TEXT, + SELECTION_ATOM_TEXT_PLAIN_UTF8, + SELECTION_ATOM_TEXT_PLAIN, + + SELECTION_N_ATOMS, +}; + +typedef struct _Efl_Selection_Manager_Data Efl_Selection_Manager_Data; +typedef struct _Sel_Manager_Seat_Selection Sel_Manager_Seat_Selection; +typedef struct _Sel_Manager_Atom Sel_Manager_Atom; +typedef struct _Sel_Manager_Dropable Sel_Manager_Dropable; +typedef struct _Anim_Icon Anim_Icon; +typedef struct _Sel_Manager_Drag_Container Sel_Manager_Drag_Container; +typedef struct _Drop_Format Drop_Format; +typedef struct _Item_Container_Drop_Info Item_Container_Drop_Info; +typedef struct _Sel_Manager_Selection Sel_Manager_Selection; +typedef struct _Tmp_Info Tmp_Info; +typedef struct _Saved_Type Saved_Type; + + +#ifdef HAVE_ELEMENTARY_X +typedef Eina_Bool (*X11_Converter_Fn_Cb) (char *target, void *data, int size, void **data_ret, int *size_ret, Ecore_X_Atom *ttype, int *typesize); +typedef int (*X11_Response_Handler_Cb) (Sel_Manager_Selection *sel, Ecore_X_Event_Selection_Notify *); +typedef Eina_Bool (*X11_Data_Preparer_Cb) (Sel_Manager_Seat_Selection *seat_sel, Ecore_X_Event_Selection_Notify *, Efl_Selection_Data *, Tmp_Info **); +#endif +#ifdef HAVE_ELEMENTARY_WL2 +typedef Eina_Bool (*Wl_Converter_Fn_Cb) (char *target, Sel_Manager_Selection *sel, void *data, int size, void **data_ret, int *size_ret); +static Eina_Bool _wl_targets_converter(char *target, Sel_Manager_Selection *sel, void *data, int size, void **data_ret, int *size_ret); +static Eina_Bool _wl_general_converter(char *target, Sel_Manager_Selection *sel, void *data, int size, void **data_ret, int *size_ret); +static Eina_Bool _wl_text_converter(char *target, Sel_Manager_Selection *sel, void *data, int size, void **data_ret, int *size_ret); + +typedef Eina_Bool (*Wl_Data_Preparer_Cb) (Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info); +static Eina_Bool _wl_data_preparer_markup(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info); +static Eina_Bool _wl_data_preparer_uri(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info); +static Eina_Bool _wl_data_preparer_vcard(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info); +static Eina_Bool _wl_data_preparer_image(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info); +static Eina_Bool _wl_data_preparer_text(Sel_Manager_Selection *sel, Efl_Selection_Data *ddata, Ecore_Wl2_Event_Offer_Data_Ready *ev, Tmp_Info **tmp_info); +#endif + + +struct _Tmp_Info +{ + char *filename; + void *map; + int fd; + int len; +}; + +struct _Saved_Type +{ + const char **types; + char *imgfile; + int ntypes; + Eina_Position2D pos; + Eina_Bool textreq: 1; +}; + +struct _Sel_Manager_Selection +{ + const char *debug; + Eina_Rw_Slice data; + Efl_Selection_Format request_format; +#ifdef HAVE_ELEMENTARY_X + Eina_Bool (*set) (Ecore_X_Window, const void *data, int size); + Eina_Bool (*clear) (void); + void (*request) (Ecore_X_Window, const char *target); + + Ecore_X_Selection ecore_sel; + Ecore_X_Window xwin; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + uint32_t selection_serial; + uint32_t drag_serial; + Ecore_Wl2_Offer *sel_offer; + Ecore_Wl2_Offer *dnd_offer; + Ecore_Event_Handler *offer_handler; + Ecore_Wl2_Window *win; +#endif +#ifdef HAVE_ELEMENTARY_COCOA + Ecore_Cocoa_Window *win; + int pb_count; +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + Eina_Bool (*set)(const Ecore_Win32_Window *window, const void *data, int size); + Eina_Bool (*clear)(const Ecore_Win32_Window *window); + Eina_Bool (*get)(const Ecore_Win32_Window *window , void **data, int *size); + Ecore_Win32_Selection ecore_sel; + Ecore_Win32_Window *win; +#endif + + Efl_Selection_Format format; + Efl_Selection_Action action; + Eina_Bool active : 1; + + Efl_Object *owner; + Efl_Object *request_obj; + void *data_func_data; + Efl_Selection_Data_Ready data_func; + Eina_Free_Cb data_func_free_cb; + + Sel_Manager_Seat_Selection *seat_sel; +}; + +typedef struct _Sel_Manager_Selection_Lost Sel_Manager_Selection_Lost; + +struct _Sel_Manager_Selection_Lost +{ + Efl_Object *request; + Eina_Promise *promise; + Efl_Selection_Type type; +}; + +struct _Sel_Manager_Seat_Selection +{ + unsigned int seat; +#ifdef HAVE_ELEMENTARY_X + Sel_Manager_Selection *sel_list; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Sel_Manager_Selection *sel; +#endif +#ifdef HAVE_ELEMENTARY_COCOA + Sel_Manager_Selection *sel; +#endif +#ifdef HAVE_ELEMENTARY_WIN32 + Sel_Manager_Selection *sel_list; +#endif + + Eina_List *sel_lost_list; + //drag + Eo *drag_obj; + Efl_Selection_Action drag_action; + Eo *drag_win; + Ecore_Event_Handler *mouse_up_handler, *dnd_status_handler; + Eina_Bool accept; + Ecore_X_Window xwin; + Eina_Position2D drag_pos; + Eina_Position2D drag_win_start; + Eina_Position2D drag_win_end; + Efl_Selection_Type active_type; + + Saved_Type *saved_types; + Ecore_Event_Handler *enter_handler; + Ecore_Event_Handler *leave_handler; + Ecore_Event_Handler *pos_handler; + Ecore_Event_Handler *drop_handler; + + Efl_Selection_Manager_Data *pd; +}; + +struct _Anim_Icon +{ + Eina_Rectangle start; + Evas_Object *obj; +}; + +struct _Sel_Manager_Drag_Container +{ + Evas *e; + Efl_Object *cont; + Efl_Selection_Format format; + Eina_Rw_Slice data; + Efl_Selection_Action action; + Eina_List *icons; + Eina_Size2D final_icon; + Eina_Position2D down; + Ecore_Timer *timer; + Ecore_Animator *animator; + double time_to_drag; + double anim_duration; + void *drag_data_func_data; + Efl_Dnd_Drag_Data_Get drag_data_func; + Eina_Free_Cb drag_data_func_free_cb; + void *item_get_func_data; + Efl_Dnd_Item_Get item_get_func; + Eina_Free_Cb item_get_func_free_cb; + void *icon_func_data; + Efl_Dnd_Drag_Icon_Create icon_func; + Eina_Free_Cb icon_func_free_cb; + void *icon_list_func_data; + Efl_Dnd_Drag_Icon_List_Create icon_list_func; + Eina_Free_Cb icon_list_func_free_cb; + unsigned int seat; + + Efl_Selection_Manager_Data *pd; +}; + +struct _Sel_Manager_Atom +{ + const char *name; + Efl_Selection_Format format; +#ifdef HAVE_ELEMENTARY_X + // Called by ecore to do conversion + X11_Converter_Fn_Cb x_converter; + X11_Data_Preparer_Cb x_data_preparer; + // Atom + Ecore_X_Atom x_atom; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Wl_Converter_Fn_Cb wl_converter; + Wl_Data_Preparer_Cb wl_data_preparer; +#endif + + void *_term; +}; + +struct _Drop_Format +{ + EINA_INLIST; + Efl_Selection_Format format; +}; + +struct _Sel_Manager_Dropable +{ + Evas_Object *obj; + Eina_Inlist *format_list; + unsigned int seat; + struct { + Eina_Position2D pos; + Eina_Bool in : 1; + const char *type; + Efl_Selection_Format format; + } last; + + //for container + Efl_Dnd_Item_Get item_func; + void *item_func_data; + Eina_Bool is_container : 1; +}; + +struct _Item_Container_Drop_Info +{ + Efl_Object *obj; + void *item_func_data; + Efl_Dnd_Item_Get item_func; +}; + +#ifdef HAVE_ELEMENTARY_WL2 +typedef struct _Wl_Format_Translation +{ + Efl_Selection_Format format; + char **translates; +} Sel_Manager_Wl_Format_Translation; + +char *sm_wl_markup[] = {"application/x-elementary-markup", "", NULL}; +char *sm_wl_text[] = {"text/plain;charset=utf-8", "text/plain", NULL}; +char *sm_wl_html[] = {"text/html;charset=utf-8", "text/html", NULL}; +char *sm_wl_vcard[] = {"text/x-vcard", NULL}; +char *sm_wl_image[] = {"image/", "text/uri-list", NULL}; + +Sel_Manager_Wl_Format_Translation sm_wl_convertion[] = { + {EFL_SELECTION_FORMAT_MARKUP, sm_wl_markup}, + {EFL_SELECTION_FORMAT_TEXT, sm_wl_text}, + {EFL_SELECTION_FORMAT_HTML, sm_wl_html}, + {EFL_SELECTION_FORMAT_VCARD, sm_wl_vcard}, + {EFL_SELECTION_FORMAT_IMAGE, sm_wl_image}, + {EFL_SELECTION_FORMAT_NONE, NULL}, +}; +#endif + +struct _Efl_Selection_Manager_Data +{ + Eo *sel_man; +#ifdef HAVE_ELEMENTARY_X + Ecore_Event_Handler *notify_handler; + Ecore_Event_Handler *clear_handler; + Ecore_Event_Handler *fix_handler; +#endif +#ifdef HAVE_ELEMENTARY_WL2 + Ecore_Event_Handler *send_handler; + Ecore_Event_Handler *changed_handler; + Ecore_Event_Handler *end_handler; + Ecore_Wl2_Display *wl_display; +#endif + Efl_Selection_Type loss_type; + + Sel_Manager_Atom *atom_list; + Eina_List *seat_list; + + Eina_List *drag_cont_list; + + //drop + Eina_List *drop_list; + Eina_Hash *type_hash; + const char *text_uri; + Eina_List *drop_cont_list; +}; + +#endif diff --git a/src/lib/elementary/efl_selection_types.eot b/src/lib/elementary/efl_selection_types.eot new file mode 100644 index 0000000000..b7ec99d7e6 --- /dev/null +++ b/src/lib/elementary/efl_selection_types.eot @@ -0,0 +1,59 @@ +enum Efl.Selection.Type +{ + [[Selection type]] + primary, [[Primary text selection (highlighted or selected text)]] + secondary, [[Used when primary selection is in use]] + dnd, [[Drag and Drop]] + clipboard [[Clipboard selection (ctrl+C)]] +} + +enum Efl.Selection.Format +{ + [[Selection format]] + targets = -1, [[For matching every possible atom]] + none = 0x0, [[Content is from outside of Elementary]] + text = 0x01, [[Plain unformatted text: Used for things that don't want rich markup]] + markup = 0x2, [[Edje textblock markup, including inline images]] + image = 0x4, [[Images]] + vcard = 0x08, [[Vcards]] + html = 0x10 [[Raw HTML-like data (eg. webkit)]] +} + +enum Efl.Selection.Action +{ + [[Defines the kind of action associated with the drop data]] + unknown, [[Action type is unknown]] + copy, [[Copy the data]] + move, [[Move the data]] + private, [[Private action type]] + ask, [[Ask the user what to do]] + list, [[List the data]] + link, [[Link the data]] + description [[Describe the data]] +} + +struct Efl.Selection.Data +{ + [[Structure holding the info about selected data]] + pos: Eina.Position2D; [[Coordinates of the drop (DND operations only)]] + format: Efl.Selection.Format; [[Format of the selection]] + data: Eina.Slice; [[Selection data]] + action: Efl.Selection.Action; [[Action to perform with the data]] + item: Efl.Object; [[Item under the drag position. It is only available for container]] +} + +function Efl.Selection.Data_Ready { + [[Function pointer for getting selection]] + params { + @in obj: Efl.Object; [[Object which requested for the selection]] + @in seldata: ptr(Efl.Selection.Data); [[Selection data]] + } +}; + +struct Efl.Selection.Changed +{ + type: Efl.Selection.Type; [[Selection type]] + seat: int; [[The seat on which the selection changed, or NULL for "default"]] + display: void_ptr; [[The display connection object, NULL under X11]] + exist: bool; [[EINA_TRUE if the selection has an owner]] +} diff --git a/src/lib/elementary/efl_ui_dnd_types.eot b/src/lib/elementary/efl_ui_dnd_types.eot new file mode 100644 index 0000000000..e07db2c276 --- /dev/null +++ b/src/lib/elementary/efl_ui_dnd_types.eot @@ -0,0 +1,58 @@ +import efl_selection_types; + +function Efl.Dnd.Drag_Icon_Create { + [[Function pointer for creating icon at the drag side.]] + params { + @in win: Efl.Canvas.Object; [[The window to create the objects relative to]] + @in drag_obj: Efl.Canvas.Object; [[The drag object]] + @out off: Eina.Position2D; + } + return: Efl.Canvas.Object; [[The drag icon object]] +}; + +function Efl.Dnd.Drag_Data_Get { + [[Function pointer for getting data and format at the drag side.]] + params { + @in obj: Efl.Canvas.Object; [[The container object]] + @out format: Efl.Selection.Format; [[Data format]] + @out drag_data: Eina.Rw_Slice; [[Data]] + @out action: Efl.Selection.Action; [[The drag action]] + } +}; + +function Efl.Dnd.Item_Get { + [[Function pointer to find out which item is under position (x, y)]] + params { + @in obj: Efl.Canvas.Object; [[The container object]] + @in pos: Eina.Position2D; [[The coordinates to get item]] + @out posret: Eina.Position2D; [[position relative to item (left (-1), middle (0), right (1)]] + } + return: ptr(Eo); [[Object under x,y coordinates or NULL if not found]] +}; + +function Efl.Dnd.Drag_Icon_List_Create { + [[Function pointer to create list of icons at the drag side. + These icons are used for animation on combining selection icons + to one icon.]] + params { + @in obj: Efl.Canvas.Object; [[The container object]] + } + return: ptr(Eina_List); +}; + +struct Efl.Dnd.Drag_Accept { + accepted: bool; +} + +struct Efl.Dnd.Drag_Pos { + pos: Eina.Position2D; [[Evas Coordinate]] + action: Efl.Selection.Action; [[The drag action]] + format: Efl.Selection.Format; [[The drag format]] + item: Efl.Canvas.Object; [[The item object. It is only available for container object.]] +} + +struct Efl.Dnd.Drag_Item_Container_Drop { + item: Efl.Canvas.Object; [[The item object]] + data: Efl.Selection.Data; [[The selection data]] + pos: Eina.Position2D; [[Position relative to item (left (-1), middle (0), right (1)]] +} diff --git a/src/lib/elementary/elm_priv.h b/src/lib/elementary/elm_priv.h index 862b56f6df..1a79d5ba81 100644 --- a/src/lib/elementary/elm_priv.h +++ b/src/lib/elementary/elm_priv.h @@ -66,6 +66,7 @@ # include "efl_ui_focus_parent_provider.eo.h" # include "efl_ui_focus_parent_provider_standard.eo.h" # include "elm_widget_item_static_focus.eo.h" +#include "efl_selection_manager.eo.h" # ifdef HAVE_LANGINFO_H # include