lib/evas/canvas/efl_event_input.eo \
lib/evas/canvas/efl_event_key.eo \
lib/evas/canvas/efl_event_pointer.eo \
+ lib/evas/canvas/efl_event_hold.eo \
$(NULL)
evas_eolian_legacy_files = \
lib/evas/canvas/efl_event_input.c \
lib/evas/canvas/efl_event_key.c \
lib/evas/canvas/efl_event_pointer.c \
+lib/evas/canvas/efl_event_hold.c \
$(NULL)
EXTRA_DIST2 += \
static void
_edje_hold_signal_cb(void *data, const Eo_Event *event)
{
- Evas_Event_Hold *ev;
+ Efl_Event_Hold *ev;
Edje *ed;
Edje_Real_Part *rp;
ed = data;
rp = evas_object_data_get(event->object, "real_part");
if (!rp) return;
- if (ev->hold)
+ if (efl_event_hold_get(ev))
_edje_emit(ed, "hold,on", rp->part->name);
else
_edje_emit(ed, "hold,off", rp->part->name);
}
EO_CALLBACKS_ARRAY_DEFINE(edje_callbacks,
- { EFL_CANVAS_OBJECT_EVENT_HOLD, _edje_hold_signal_cb },
+ { EFL_EVENT_HOLD, _edje_hold_signal_cb },
{ EFL_EVENT_POINTER_IN, _edje_mouse_in_signal_cb },
{ EFL_EVENT_POINTER_OUT, _edje_mouse_out_signal_cb },
{ EFL_EVENT_POINTER_DOWN, _edje_mouse_down_signal_cb },
typedef struct _Efl_Event_Pointer_Data Efl_Event_Pointer_Data;
typedef struct _Efl_Event_Key_Data Efl_Event_Key_Data;
typedef struct _Efl_Input_Device_Data Efl_Input_Device_Data;
+typedef struct _Efl_Event_Hold_Data Efl_Event_Hold_Data;
#ifndef _EVAS_TYPES_EOT_H_
typedef struct _Evas_Modifier Evas_Modifier;
Efl_Input_Device_Sub_Class subclass;
};
+struct _Efl_Event_Hold_Data
+{
+ Eo *eo;
+ double timestamp;
+ Efl_Input_Device *device;
+ void *data;
+ Eina_Bool hold : 1;
+ Eina_Bool evas_done : 1; /* set by evas */
+};
+
#endif
pointer,wheel: Efl.Event.Pointer;
key,down: Efl.Event.Key;
key,up: Efl.Event.Key;
+ hold: Efl.Event.Hold; [[All input events are on hold or resumed.]]
}
}
#ifdef EFL_EO_API_SUPPORT
#include "canvas/efl_event_input.eo.h"
#include "canvas/efl_event_pointer.eo.h"
-#endif /* EFL_EO_API_SUPPORT */
#include "canvas/efl_event_key.eo.h"
+#include "canvas/efl_event_hold.eo.h"
+#endif /* EFL_EO_API_SUPPORT */
focus,in; [[Focus In Event ]]
focus,out; [[Focus Out Event ]]
del @beta; [[Object Being Deleted (called before Free) ]]
- hold; [[Events go on/off hold ]]
+ hold @beta; [[Events go on/off hold ]]
}
}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Evas.h>
+
+#define EFL_INTERNAL_UNSTABLE
+#include "interfaces/efl_common_internal.h"
+
+#define MY_CLASS EFL_EVENT_HOLD_CLASS
+
+EOLIAN static void
+_efl_event_hold_hold_set(Eo *obj EINA_UNUSED, Efl_Event_Hold_Data *pd, Eina_Bool val)
+{
+ pd->hold = !!val;
+}
+
+EOLIAN static Eina_Bool
+_efl_event_hold_hold_get(Eo *obj EINA_UNUSED, Efl_Event_Hold_Data *pd)
+{
+ return pd->hold;
+}
+
+EOLIAN static void
+_efl_event_hold_device_set(Eo *obj EINA_UNUSED, Efl_Event_Hold_Data *pd, Efl_Input_Device *dev)
+{
+ pd->device = dev;
+}
+
+EOLIAN static Efl_Input_Device *
+_efl_event_hold_device_get(Eo *obj EINA_UNUSED, Efl_Event_Hold_Data *pd)
+{
+ return pd->device;
+}
+
+EOLIAN static double
+_efl_event_hold_efl_event_timestamp_get(Eo *obj EINA_UNUSED, Efl_Event_Hold_Data *pd)
+{
+ return pd->timestamp;
+}
+
+EOLIAN static void
+_efl_event_hold_efl_event_timestamp_set(Eo *obj EINA_UNUSED, Efl_Event_Hold_Data *pd, double ms)
+{
+ pd->timestamp = ms;
+}
+
+EOLIAN static Eo *
+_efl_event_hold_eo_base_constructor(Eo *obj, Efl_Event_Hold_Data *pd)
+{
+ obj = eo_constructor(eo_super(obj, MY_CLASS));
+ pd->eo = obj;
+ return obj;
+}
+
+#include "efl_event_hold.eo.c"
--- /dev/null
+class Efl.Event.Hold (Eo.Base, Efl.Event.Input)
+{
+ [[Event data sent when inputs are put on hold or resumed.]]
+ methods {
+ @property hold {
+ [[$true if inputs are now on hold.]]
+ values {
+ val: bool;
+ }
+ }
+ @property device {
+ [[Input device that is now on hold or resumed.]]
+ values {
+ dev: Efl.Input.Device;
+ }
+ }
+ /* FIXME: does not expose event_flags - is it necessary? */
+ }
+ implements {
+ Eo.Base.constructor;
+ Efl.Event.timestamp.get;
+ Efl.Event.timestamp.set;
+ }
+}
EV_CASE(MOUSE_WHEEL, Mouse_Wheel, POINTER, pointer);
EV_CASE(KEY_DOWN, Key_Down, KEY, key);
EV_CASE(KEY_UP, Key_Up, KEY, key);
+ EV_CASE(HOLD, Hold, HOLD, hold);
default:
DBG("Support for event type %d not implemented yet.", type);
}
static void
-_evas_event_source_hold_events(Evas_Object *eo_obj, Evas *eo_e EINA_UNUSED, void *ev, int event_id)
+_evas_event_source_hold_events(Evas_Object *eo_obj, Evas *eo_e EINA_UNUSED, void *ev,
+ int event_id, Efl_Event_Hold *parent_he)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
Evas_Object_Protected_Data *src = eo_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
+ Evas_Object_Protected_Data *child;
+ Efl_Event_Hold *he = NULL;
+ Evas_Object *eo_child;
+ Eina_List *l;
if (obj->layer->evas->is_frozen) return;
- Eina_List *l;
- Evas_Object *child_eo;
- Evas_Object_Protected_Data *child;
- EINA_LIST_FOREACH(src->proxy->src_event_in, l, child_eo)
+ EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
{
if (src->delete_me) return;
- child = eo_data_scope_get(child_eo, EFL_CANVAS_OBJECT_CLASS);
- evas_object_event_callback_call(child_eo, child, EVAS_CALLBACK_HOLD, ev,
- event_id, NULL, NULL);
+ child = eo_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
+ EV_CALL(eo_child, child, EVAS_CALLBACK_HOLD, ev, event_id, he, parent_he);
if (src->layer->evas->delete_me) break;
}
+
+ EV_DEL(he);
}
static void
evas_event_feed_hold(Eo *eo_e, int hold, unsigned int timestamp, const void *data)
{
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
+ Efl_Event_Hold *he = NULL;
Eina_List *l, *copy;
Evas_Event_Hold ev;
Evas_Object *eo_obj;
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
if ( !evas_event_freezes_through(eo_obj, obj))
{
- evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_HOLD,
- &ev, event_id, NULL, NULL);
+ EV_CALL(eo_obj, obj, EVAS_CALLBACK_HOLD, &ev, event_id, he, NULL);
if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
- _evas_event_source_hold_events(eo_obj, eo_e, &ev, event_id);
+ _evas_event_source_hold_events(eo_obj, eo_e, &ev, event_id, he);
}
if (e->delete_me || e->is_frozen) break;
}
if (ev.dev) eo_unref(ev.dev);
_evas_unwalk(e);
_evas_object_event_new();
+
+ EV_DEL(he);
}
void
ev->evas_done = EINA_TRUE;
}
+// note: "hold" event comes from above (elm), not below (ecore)
EO_CALLBACKS_ARRAY_DEFINE(_evas_canvas_event_pointer_callbacks,
{ EFL_EVENT_POINTER_MOVE, _evas_canvas_event_pointer_cb },
{ EFL_EVENT_POINTER_DOWN, _evas_canvas_event_pointer_cb },
return EINA_TRUE;
}
+
+Eina_Bool
+efl_event_hold_legacy_info_set(Efl_Event_Hold *evt, const void *event_info, Evas_Callback_Type type)
+{
+ Efl_Event_Hold_Data *ev = eo_data_scope_get(evt, EFL_EVENT_HOLD_CLASS);
+ const Evas_Event_Hold *e = event_info;
+
+ if (!ev || !event_info) return EINA_FALSE;
+
+ if (type != EVAS_CALLBACK_HOLD)
+ {
+ ERR("invalid event type %d", type);
+ return EINA_FALSE;
+ }
+
+ ev->timestamp = e->timestamp;
+ ev->device = e->dev;
+ ev->hold = !!e->hold;
+
+ return EINA_TRUE;
+}
/* legacy/eo events */
Eina_Bool efl_event_pointer_legacy_info_set(Efl_Event_Pointer *evt, const void *event_info, Evas_Callback_Type type);
Eina_Bool efl_event_key_legacy_info_set(Efl_Event_Key *evt, const void *event_info, Evas_Callback_Type type);
+Eina_Bool efl_event_hold_legacy_info_set(Efl_Event_Hold *evt, const void *event_info, Evas_Callback_Type type);
Eina_Bool evas_vg_loader_svg(Evas_Object *vg, const Eina_File *f, const char *key EINA_UNUSED);