enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity
efl/src/lib/elementary/elm_dnd.c

835 lines
25 KiB
C
Raw Blame History

#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#include <Elementary.h>
#include "elm_priv.h"
int ELM_CNP_EVENT_SELECTION_CHANGED;
typedef struct {
void *enter_data, *leave_data, *pos_data, *drop_data;
Elm_Drag_State enter_cb;
Elm_Drag_State leave_cb;
Elm_Drag_Pos pos_cb;
Elm_Drop_Cb drop_cb;
Eina_Array *mime_types;
Elm_Sel_Format format;
Elm_Xdnd_Action action;
} Elm_Drop_Target;
static int
_default_seat(const Eo *obj)
{
return evas_device_seat_id_get(evas_default_device_get(evas_object_evas_get(obj), EVAS_DEVICE_CLASS_SEAT));
}
static const char*
_action_to_string(Elm_Xdnd_Action action)
{
if (action == ELM_XDND_ACTION_COPY) return "copy";
if (action == ELM_XDND_ACTION_MOVE) return "move";
if (action == ELM_XDND_ACTION_PRIVATE) return "private";
if (action == ELM_XDND_ACTION_ASK) return "ask";
if (action == ELM_XDND_ACTION_LIST) return "list";
if (action == ELM_XDND_ACTION_LINK) return "link";
if (action == ELM_XDND_ACTION_DESCRIPTION) return "description";
return "unknown";
}
static Elm_Xdnd_Action
_string_to_action(const char* action)
{
if (eina_streq(action, "copy")) return ELM_XDND_ACTION_COPY;
else if (eina_streq(action, "move")) return ELM_XDND_ACTION_MOVE;
else if (eina_streq(action, "private")) return ELM_XDND_ACTION_PRIVATE;
else if (eina_streq(action, "ask")) return ELM_XDND_ACTION_ASK;
else if (eina_streq(action, "list")) return ELM_XDND_ACTION_LIST;
else if (eina_streq(action, "link")) return ELM_XDND_ACTION_LINK;
else if (eina_streq(action, "description")) return ELM_XDND_ACTION_DESCRIPTION;
return ELM_XDND_ACTION_UNKNOWN;
}
static void
_enter_cb(void *data, const Efl_Event *ev)
{
Elm_Drop_Target *target = data;
if (target->enter_cb)
target->enter_cb(target->enter_data, ev->object);
}
static void
_leave_cb(void *data, const Efl_Event *ev)
{
Elm_Drop_Target *target = data;
if (target->leave_cb)
target->leave_cb(target->leave_data, ev->object);
}
static void
_pos_cb(void *data, const Efl_Event *ev)
{
Elm_Drop_Target *target = data;
Efl_Ui_Drop_Event *event = ev->info;
if (target->pos_cb)
target->pos_cb(target->pos_data, ev->object, event->position.x, event->position.y, target->action); //FIXME action
}
static Eina_Value
_deliver_content(Eo *obj, void *data, const Eina_Value value)
{
Elm_Drop_Target *target = data;
Elm_Selection_Data sel_data;
Eina_Content *content = eina_value_to_content(&value);
sel_data.data = (void*)eina_content_data_get(content).mem;
sel_data.len = eina_content_data_get(content).len;
sel_data.action = target->action;
sel_data.format = target->format;
if (target->drop_cb)
target->drop_cb(target->drop_data, obj, &sel_data);
return EINA_VALUE_EMPTY;
}
static void
_drop_cb(void *data, const Efl_Event *ev)
{
Efl_Ui_Drop_Dropped_Event *event = ev->info;
Elm_Drop_Target *target = data;
target->action = _string_to_action(event->action);
efl_future_then(ev->object, efl_ui_dnd_drop_data_get(elm_widget_is(ev->object) ? ev->object : efl_ui_win_get(ev->object), _default_seat(ev->object), eina_array_iterator_new(target->mime_types)),
.success = _deliver_content,
.data = target
);
}
static void
_inv_cb(void *data, const Efl_Event *ev)
{
Elm_Drop_Target *target = data;
elm_drop_target_del(ev->object, target->format, target->enter_cb, target->enter_data, target->leave_cb,
target->leave_data, target->pos_cb, target->pos_data, target->drop_cb, target->drop_data);
}
EFL_CALLBACKS_ARRAY_DEFINE(drop_target_cb,
{EFL_UI_DND_EVENT_DROP_ENTERED, _enter_cb},
{EFL_UI_DND_EVENT_DROP_LEFT, _leave_cb},
{EFL_UI_DND_EVENT_DROP_POSITION_CHANGED, _pos_cb},
{EFL_UI_DND_EVENT_DROP_DROPPED, _drop_cb},
{EFL_EVENT_INVALIDATE, _inv_cb}
)
static Eina_Hash *target_register = NULL;
static Eina_Array*
_format_to_mime_array(Elm_Sel_Format format)
{
Eina_Array *ret = eina_array_new(10);
if (format & ELM_SEL_FORMAT_URILIST)
eina_array_push(ret, "text/uri-list");
if (format & ELM_SEL_FORMAT_TEXT)
{
eina_array_push(ret, "text/plain");
eina_array_push(ret, "text/plain;charset=utf-8");
if (!(format & ELM_SEL_FORMAT_URILIST))
eina_array_push(ret, "text/uri-list");
}
if (format & ELM_SEL_FORMAT_MARKUP)
eina_array_push(ret, "application/x-elementary-markup");
if (format & ELM_SEL_FORMAT_IMAGE)
{
eina_array_push(ret, "image/png");
eina_array_push(ret, "image/jpeg");
eina_array_push(ret, "image/x-ms-bmp");
eina_array_push(ret, "image/gif");
eina_array_push(ret, "image/tiff");
eina_array_push(ret, "image/svg+xml");
eina_array_push(ret, "image/x-xpixmap");
eina_array_push(ret, "image/x-tga");
eina_array_push(ret, "image/x-portable-pixmap");
}
if (format & ELM_SEL_FORMAT_VCARD)
eina_array_push(ret, "text/vcard");
if (format & ELM_SEL_FORMAT_HTML)
eina_array_push(ret, "text/html");
return ret;
}
EAPI Eina_Bool
elm_drop_target_add(Evas_Object *obj, Elm_Sel_Format format,
Elm_Drag_State enter_cb, void *enter_data,
Elm_Drag_State leave_cb, void *leave_data,
Elm_Drag_Pos pos_cb, void *pos_data,
Elm_Drop_Cb drop_cb, void *drop_data)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
Elm_Drop_Target *target = calloc(1, sizeof(Elm_Drop_Target));
target->enter_cb = enter_cb;
target->enter_data = enter_data;
target->leave_cb = leave_cb;
target->leave_data = leave_data;
target->pos_cb = pos_cb;
target->pos_data = pos_data;
target->drop_cb = drop_cb;
target->drop_data = drop_data;
target->mime_types = _format_to_mime_array(format);
target->format = format;
efl_event_callback_array_add(obj, drop_target_cb(), target);
if (!efl_isa(obj, EFL_UI_WIDGET_CLASS))
_drop_event_register(obj); //this is ensuring that we are also supporting none widgets
if (!target_register)
target_register = eina_hash_pointer_new(NULL);
eina_hash_list_append(target_register, &obj, target);
return EINA_TRUE;
}
EAPI Eina_Bool
elm_drop_target_del(Evas_Object *obj, Elm_Sel_Format format,
Elm_Drag_State enter_cb, void *enter_data,
Elm_Drag_State leave_cb, void *leave_data,
Elm_Drag_Pos pos_cb, void *pos_data,
Elm_Drop_Cb drop_cb, void *drop_data)
{
Elm_Drop_Target *target;
Eina_List *n, *found = NULL;
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
if (!target_register)
return EINA_TRUE;
Eina_List *targets = eina_hash_find(target_register, &obj);
if (!targets)
return EINA_TRUE;
EINA_LIST_FOREACH(targets, n, target)
{
if (target->enter_cb == enter_cb && target->enter_data == enter_data &&
target->leave_cb == leave_cb && target->leave_data == leave_data &&
target->pos_cb == pos_cb && target->pos_data == pos_data &&
target->drop_cb == drop_cb && target->drop_data == drop_data &&
target->format == format)
{
found = n;
break;
}
}
if (found)
{
efl_event_callback_array_del(obj, drop_target_cb(), eina_list_data_get(found));
eina_hash_list_remove(target_register, &obj, target);
eina_array_free(target->mime_types);
_drop_event_unregister(obj); //this is ensuring that we are also supporting none widgets
free(target);
}
return EINA_TRUE;
}
struct _Item_Container_Drag_Info
{ /* Info kept for containers to support drag */
Evas_Object *obj;
Ecore_Timer *tm; /* When this expires, start drag */
double anim_tm; /* Time period to set tm */
double tm_to_drag; /* Time period to set tm */
Elm_Xy_Item_Get_Cb itemgetcb;
Elm_Item_Container_Data_Get_Cb data_get;
Evas_Coord x_down; /* Mouse down x cord when drag starts */
Evas_Coord y_down; /* Mouse down y cord when drag starts */
/* Some extra information needed to impl default anim */
Evas *e;
Eina_List *icons; /* List of icons to animate (Anim_Icon) */
int final_icon_w; /* We need the w and h of the final icon for the animation */
int final_icon_h;
Ecore_Animator *ea;
Elm_Drag_User_Info user_info;
};
typedef struct _Item_Container_Drag_Info Item_Container_Drag_Info;
struct _Anim_Icon
{
int start_x;
int start_y;
int start_w;
int start_h;
Evas_Object *o;
};
typedef struct _Anim_Icon Anim_Icon;
static Eina_List *cont_drag_tg = NULL; /* List of Item_Container_Drag_Info */
static Eina_Bool elm_drag_item_container_del_internal(Evas_Object *obj, Eina_Bool full);
static void _cont_obj_mouse_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info);
static void _cont_obj_mouse_up(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info);
static void _cont_obj_mouse_down(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info);
static void
_cont_drag_done_cb(void *data, Evas_Object *obj EINA_UNUSED)
{
Item_Container_Drag_Info *st = data;
elm_widget_scroll_freeze_pop(st->obj);
if (st->user_info.dragdone)
st->user_info.dragdone(st->user_info.donecbdata, NULL, EINA_FALSE); /*FIXME*/
}
static Eina_Bool
_cont_obj_drag_start(void *data)
{ /* Start a drag-action when timer expires */
Item_Container_Drag_Info *st = data;
st->tm = NULL;
Elm_Drag_User_Info *info = &st->user_info;
if (info->dragstart) info->dragstart(info->startcbdata, st->obj);
elm_widget_scroll_freeze_push(st->obj);
evas_object_event_callback_del_full
(st->obj, EVAS_CALLBACK_MOUSE_MOVE, _cont_obj_mouse_move, st);
elm_drag_start( /* Commit the start only if data_get successful */
st->obj, info->format,
info->data, info->action,
info->createicon, info->createdata,
info->dragpos, info->dragdata,
info->acceptcb, info->acceptdata,
_cont_drag_done_cb, st);
ELM_SAFE_FREE(info->data, free);
return ECORE_CALLBACK_CANCEL;
}
static inline Eina_List *
_anim_icons_make(Eina_List *icons)
{ /* Make local copies of all icons, add them to list */
Eina_List *list = NULL, *itr;
Evas_Object *o;
EINA_LIST_FOREACH(icons, itr, o)
{ /* Now add icons to animation window */
Anim_Icon *st = calloc(1, sizeof(*st));
if (!st)
{
ERR("Failed to allocate memory for icon!");
continue;
}
evas_object_geometry_get(o, &st->start_x, &st->start_y, &st->start_w, &st->start_h);
evas_object_show(o);
st->o = o;
list = eina_list_append(list, st);
}
return list;
}
static Eina_Bool
_drag_anim_play(void *data, double pos)
{ /* Impl of the animation of icons, called on frame time */
Item_Container_Drag_Info *st = data;
Eina_List *l;
Anim_Icon *sti;
if (st->ea)
{
if (pos > 0.99)
{
st->ea = NULL; /* Avoid deleting on mouse up */
EINA_LIST_FOREACH(st->icons, l, sti)
evas_object_hide(sti->o);
_cont_obj_drag_start(st); /* Start dragging */
return ECORE_CALLBACK_CANCEL;
}
Evas_Coord xm, ym;
evas_pointer_canvas_xy_get(st->e, &xm, &ym);
EINA_LIST_FOREACH(st->icons, l, sti)
{
int x, y, h, w;
w = sti->start_w + ((st->final_icon_w - sti->start_w) * pos);
h = sti->start_h + ((st->final_icon_h - sti->start_h) * pos);
x = sti->start_x - (pos * ((sti->start_x + (w/2) - xm)));
y = sti->start_y - (pos * ((sti->start_y + (h/2) - ym)));
evas_object_move(sti->o, x, y);
evas_object_resize(sti->o, w, h);
}
return ECORE_CALLBACK_RENEW;
}
return ECORE_CALLBACK_CANCEL;
}
static inline Eina_Bool
_drag_anim_start(void *data)
{ /* Start default animation */
Item_Container_Drag_Info *st = data;
st->tm = NULL;
/* Now we need to build an (Anim_Icon *) list */
st->icons = _anim_icons_make(st->user_info.icons);
if (st->user_info.createicon)
{
Evas_Object *temp_win = elm_win_add(NULL, "Temp", ELM_WIN_DND);
Evas_Object *final_icon = st->user_info.createicon(st->user_info.createdata, temp_win, NULL, NULL);
evas_object_geometry_get(final_icon, NULL, NULL, &st->final_icon_w, &st->final_icon_h);
evas_object_del(final_icon);
evas_object_del(temp_win);
}
st->ea = ecore_animator_timeline_add(st->anim_tm, _drag_anim_play, st);
return EINA_FALSE;
}
static Eina_Bool
_cont_obj_anim_start(void *data)
{ /* Start a drag-action when timer expires */
Item_Container_Drag_Info *st = data;
int xposret, yposret; /* Unused */
Elm_Object_Item *it = (st->itemgetcb) ?
(st->itemgetcb(st->obj, st->x_down, st->y_down, &xposret, &yposret))
: NULL;
st->tm = NULL;
st->user_info.format = ELM_SEL_FORMAT_TARGETS; /* Default */
st->icons = NULL;
st->user_info.data = NULL;
st->user_info.action = ELM_XDND_ACTION_COPY; /* Default */
if (!it) /* Failed to get mouse-down item, abort drag */
return ECORE_CALLBACK_CANCEL;
if (st->data_get)
{ /* collect info then start animation or start dragging */
if (st->data_get( /* Collect drag info */
st->obj, /* The container object */
it, /* Drag started on this item */
&st->user_info))
{
if (st->user_info.icons)
_drag_anim_start(st);
else
{
if (EINA_DBL_NONZERO(st->anim_tm))
{
// even if we don't manage the icons animation, we have
// to wait until it is finished before beginning drag.
st->tm = ecore_timer_add(st->anim_tm, _cont_obj_drag_start, st);
}
else
_cont_obj_drag_start(st); /* Start dragging, no anim */
}
}
}
return ECORE_CALLBACK_CANCEL;
}
static int
_drag_item_container_cmp(const void *d1,
const void *d2)
{
const Item_Container_Drag_Info *st = d1;
return (((uintptr_t) (st->obj)) - ((uintptr_t) d2));
}
void
_anim_st_free(Item_Container_Drag_Info *st)
{ /* Stops and free mem of ongoing animation */
if (st)
{
ELM_SAFE_FREE(st->ea, ecore_animator_del);
Anim_Icon *sti;
EINA_LIST_FREE(st->icons, sti)
{
evas_object_del(sti->o);
free(sti);
}
st->icons = NULL;
}
}
static void
_cont_obj_mouse_up(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
{ /* Cancel any drag waiting to start on timeout */
Item_Container_Drag_Info *st = data;
if (((Evas_Event_Mouse_Up *)event_info)->button != 1)
return; /* We only process left-click at the moment */
evas_object_event_callback_del_full
(st->obj, EVAS_CALLBACK_MOUSE_MOVE, _cont_obj_mouse_move, st);
evas_object_event_callback_del_full
(st->obj, EVAS_CALLBACK_MOUSE_UP, _cont_obj_mouse_up, st);
ELM_SAFE_FREE(st->tm, ecore_timer_del);
_anim_st_free(st);
}
static void
_cont_obj_mouse_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
{ /* Cancel any drag waiting to start on timeout */
if (((Evas_Event_Mouse_Move *)event_info)->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
{
Item_Container_Drag_Info *st = data;
evas_object_event_callback_del_full
(st->obj, EVAS_CALLBACK_MOUSE_MOVE, _cont_obj_mouse_move, st);
evas_object_event_callback_del_full
(st->obj, EVAS_CALLBACK_MOUSE_UP, _cont_obj_mouse_up, st);
elm_drag_item_container_del_internal(obj, EINA_FALSE);
ELM_SAFE_FREE(st->tm, ecore_timer_del);
_anim_st_free(st);
}
}
static Eina_Bool
elm_drag_item_container_del_internal(Evas_Object *obj, Eina_Bool full)
{
Item_Container_Drag_Info *st =
eina_list_search_unsorted(cont_drag_tg, _drag_item_container_cmp, obj);
if (st)
{
ELM_SAFE_FREE(st->tm, ecore_timer_del); /* Cancel drag-start timer */
if (st->ea) /* Cancel ongoing default animation */
_anim_st_free(st);
if (full)
{
st->itemgetcb = NULL;
st->data_get = NULL;
evas_object_event_callback_del_full
(obj, EVAS_CALLBACK_MOUSE_DOWN, _cont_obj_mouse_down, st);
cont_drag_tg = eina_list_remove(cont_drag_tg, st);
ELM_SAFE_FREE(st->user_info.data, free);
free(st);
}
return EINA_TRUE;
}
return EINA_FALSE;
}
static void
_cont_obj_mouse_down(void *data, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info)
{ /* Launch a timer to start dragging */
Evas_Event_Mouse_Down *ev = event_info;
if (ev->button != 1)
return; /* We only process left-click at the moment */
Item_Container_Drag_Info *st = data;
evas_object_event_callback_add(st->obj, EVAS_CALLBACK_MOUSE_MOVE,
_cont_obj_mouse_move, st);
evas_object_event_callback_add(st->obj, EVAS_CALLBACK_MOUSE_UP,
_cont_obj_mouse_up, st);
ecore_timer_del(st->tm);
st->e = e;
st->x_down = ev->canvas.x;
st->y_down = ev->canvas.y;
st->tm = ecore_timer_add(st->tm_to_drag, _cont_obj_anim_start, st);
}
EAPI Eina_Bool
elm_drag_item_container_del(Evas_Object *obj)
{
return elm_drag_item_container_del_internal(obj, EINA_TRUE);
}
EAPI Eina_Bool
elm_drag_item_container_add(Evas_Object *obj,
double anim_tm,
double tm_to_drag,
Elm_Xy_Item_Get_Cb itemgetcb,
Elm_Item_Container_Data_Get_Cb data_get)
{
Item_Container_Drag_Info *st;
if (elm_drag_item_container_del_internal(obj, EINA_FALSE))
{ /* Updating info of existing obj */
st = eina_list_search_unsorted(cont_drag_tg, _drag_item_container_cmp, obj);
if (!st) return EINA_FALSE;
}
else
{
st = calloc(1, sizeof(*st));
if (!st) return EINA_FALSE;
st->obj = obj;
cont_drag_tg = eina_list_append(cont_drag_tg, st);
/* Register for mouse callback for container to start/abort drag */
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_DOWN,
_cont_obj_mouse_down, st);
}
st->tm = NULL;
st->anim_tm = anim_tm;
st->tm_to_drag = tm_to_drag;
st->itemgetcb = itemgetcb;
st->data_get = data_get;
return EINA_TRUE;
}
static Eina_List *cont_drop_tg = NULL; /* List of Item_Container_Drop_Info */
struct _Item_Container_Drop_Info
{ /* Info kept for containers to support drop */
Evas_Object *obj;
Elm_Xy_Item_Get_Cb itemgetcb;
Elm_Drop_Item_Container_Cb dropcb;
Elm_Drag_Item_Container_Pos poscb;
};
typedef struct _Item_Container_Drop_Info Item_Container_Drop_Info;
typedef struct
{
Evas_Object *obj;
/* FIXME: Cache window */
Eina_Inlist *cbs_list; /* List of Dropable_Cbs * */
struct {
Evas_Coord x, y;
Eina_Bool in : 1;
const char *type;
Elm_Sel_Format format;
} last;
} Dropable;
static int
_drop_item_container_cmp(const void *d1,
const void *d2)
{
const Item_Container_Drop_Info *st = d1;
return (((uintptr_t) (st->obj)) - ((uintptr_t) d2));
}
static void
_elm_item_container_pos_cb(void *data, Evas_Object *obj, Evas_Coord x, Evas_Coord y, Elm_Xdnd_Action action)
{ /* obj is the container pointer */
Elm_Object_Item *it = NULL;
int xposret = 0;
int yposret = 0;
Item_Container_Drop_Info *st =
eina_list_search_unsorted(cont_drop_tg, _drop_item_container_cmp, obj);
if (st && st->poscb)
{ /* Call container drop func with specific item pointer */
int xo = 0;
int yo = 0;
evas_object_geometry_get(obj, &xo, &yo, NULL, NULL);
if (st->itemgetcb)
it = st->itemgetcb(obj, x+xo, y+yo, &xposret, &yposret);
st->poscb(data, obj, it, x, y, xposret, yposret, action);
}
}
static Eina_Bool
_elm_item_container_drop_cb(void *data, Evas_Object *obj , Elm_Selection_Data *ev)
{ /* obj is the container pointer */
Elm_Object_Item *it = NULL;
int xposret = 0;
int yposret = 0;
Item_Container_Drop_Info *st =
eina_list_search_unsorted(cont_drop_tg, _drop_item_container_cmp, obj);
if (st && st->dropcb)
{ /* Call container drop func with specific item pointer */
int xo = 0;
int yo = 0;
evas_object_geometry_get(obj, &xo, &yo, NULL, NULL);
if (st->itemgetcb)
it = st->itemgetcb(obj, ev->x+xo, ev->y+yo, &xposret, &yposret);
return st->dropcb(data, obj, it, ev, xposret, yposret);
}
return EINA_FALSE;
}
static Eina_Bool
elm_drop_item_container_del_internal(Evas_Object *obj, Eina_Bool full)
{
Item_Container_Drop_Info *st =
eina_list_search_unsorted(cont_drop_tg, _drop_item_container_cmp, obj);
if (st)
{
// temp until st is stored inside data of obj.
//FIXME delete this drop container
st->itemgetcb= NULL;
st->poscb = NULL;
st->dropcb = NULL;
if (full)
{
cont_drop_tg = eina_list_remove(cont_drop_tg, st);
free(st);
}
return EINA_TRUE;
}
return EINA_FALSE;
}
EAPI Eina_Bool
elm_drop_item_container_add(Evas_Object *obj,
Elm_Sel_Format format,
Elm_Xy_Item_Get_Cb itemgetcb,
Elm_Drag_State entercb, void *enterdata,
Elm_Drag_State leavecb, void *leavedata,
Elm_Drag_Item_Container_Pos poscb, void *posdata,
Elm_Drop_Item_Container_Cb dropcb, void *dropdata)
{
Item_Container_Drop_Info *st;
if (elm_drop_item_container_del_internal(obj, EINA_FALSE))
{ /* Updating info of existing obj */
st = eina_list_search_unsorted(cont_drop_tg, _drop_item_container_cmp, obj);
if (!st) return EINA_FALSE;
}
else
{
st = calloc(1, sizeof(*st));
if (!st) return EINA_FALSE;
st->obj = obj;
cont_drop_tg = eina_list_append(cont_drop_tg, st);
}
st->itemgetcb = itemgetcb;
st->poscb = poscb;
st->dropcb = dropcb;
elm_drop_target_add(obj, format,
entercb, enterdata,
leavecb, leavedata,
_elm_item_container_pos_cb, posdata,
_elm_item_container_drop_cb, dropdata);
return EINA_TRUE;
}
EAPI Eina_Bool
elm_drop_item_container_del(Evas_Object *obj)
{
return elm_drop_item_container_del_internal(obj, EINA_TRUE);
}
typedef struct {
void *dragdata, *acceptdata, *donecbdata;
Elm_Drag_Pos dragposcb;
Elm_Drag_Accept acceptcb;
Elm_Drag_State dragdonecb;
} Elm_Drag_Data;
static void
_drag_finished_cb(void *data, const Efl_Event *ev)
{
Elm_Drag_Data *dd = data;
Eina_Bool *accepted = ev->info;
if (dd->acceptcb)
dd->acceptcb(dd->acceptdata, ev->object, *accepted);
if (dd->dragdonecb)
dd->dragdonecb(dd->donecbdata, ev->object);
efl_event_callback_del(ev->object, EFL_UI_DND_EVENT_DRAG_FINISHED, _drag_finished_cb, dd);
free(dd);
}
EAPI Eina_Bool
elm_drag_start(Evas_Object *obj, Elm_Sel_Format format,
const char *data, Elm_Xdnd_Action action,
Elm_Drag_Icon_Create_Cb createicon,
void *createdata,
Elm_Drag_Pos dragpos, void *dragdata,
Elm_Drag_Accept acceptcb, void *acceptdata,
Elm_Drag_State dragdone, void *donecbdata)
{
Eina_Array *mime_types;
Eina_Content *content;
Efl_Content *ui;
int x = 0, y = 0, w, h;
Efl_Ui_Widget *widget;
Elm_Drag_Data *dd;
const char *str_action;
Eina_Position2D pointer;
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
//it should return EINA_TRUE to keep backward compatibility
if (!data)
return EINA_TRUE;
str_action = _action_to_string(action);
dd = calloc(1, sizeof(Elm_Drag_Data));
dd->dragposcb = dragpos;
dd->dragdata = dragdata;
dd->acceptcb = acceptcb;
dd->acceptdata = acceptdata;
dd->dragdonecb = dragdone;
dd->donecbdata = donecbdata;
mime_types = _format_to_mime_array(format);
if (eina_array_count(mime_types) != 1)
{
WRN("You passed more than one format, this is not going to work well");
}
content = eina_content_new((Eina_Slice) EINA_SLICE_STR_FULL(data), eina_array_data_get(mime_types, 0));
ui = efl_ui_dnd_drag_start(obj, content, str_action, _default_seat(obj));
widget = createicon(createdata, ui, &x, &y);
evas_pointer_canvas_xy_get(evas_object_evas_get(obj), &pointer.x, &pointer.y);
efl_ui_dnd_drag_offset_set(obj, _default_seat(obj), EINA_SIZE2D(x - pointer.x, y - pointer.y));
evas_object_geometry_get(widget, NULL, NULL, &w, &h);
evas_object_show(widget);
efl_content_set(ui, widget);
efl_gfx_entity_size_set(ui, EINA_SIZE2D(w, h));
eina_array_free(mime_types);
efl_event_callback_add(obj, EFL_UI_DND_EVENT_DRAG_FINISHED, _drag_finished_cb, dd);
return EINA_TRUE;
}
EAPI Eina_Bool
elm_drag_cancel(Evas_Object *obj)
{
efl_ui_dnd_drag_cancel(obj, _default_seat(obj));
return EINA_TRUE;
}
EAPI Eina_Bool
elm_drag_action_set(Evas_Object *obj EINA_UNUSED, Elm_Xdnd_Action action EINA_UNUSED)
{
ERR("This operation is not supported anymore.");
return EINA_FALSE;
}
Reference in New Issue View Git Blame Copy Permalink