#include <Efl_Config.h>
+#include "ecore_input_device.eo.h"
+
/**
* @ingroup Ecore
* @defgroup Ecore_Init_Group Ecore initialization, shutdown functions and reset on fork.
//typedef Efl_Input_Device_Type Ecore_Device_Class;
//
-#define ECORE_DEVICE_CLASS_NONE EFL_INPUT_DEVICE_TYPE_NONE /**< Not a device @since 1.8 */
-#define ECORE_DEVICE_CLASS_SEAT EFL_INPUT_DEVICE_TYPE_SEAT /**< The user/seat (the user themselves) @since 1.8 */
-#define ECORE_DEVICE_CLASS_KEYBOARD EFL_INPUT_DEVICE_TYPE_KEYBOARD /**< A regular keyboard, numberpad or attached buttons @since 1.8 */
-#define ECORE_DEVICE_CLASS_MOUSE EFL_INPUT_DEVICE_TYPE_MOUSE /**< A mouse, trackball or touchpad relative motion device @since 1.8 */
-#define ECORE_DEVICE_CLASS_TOUCH EFL_INPUT_DEVICE_TYPE_TOUCH /**< A touchscreen with fingers or stylus @since 1.8 */
-#define ECORE_DEVICE_CLASS_PEN EFL_INPUT_DEVICE_TYPE_PEN /**< A special pen device @since 1.8 */
-#define ECORE_DEVICE_CLASS_POINTER EFL_INPUT_DEVICE_TYPE_WAND /**< A laser pointer, wii-style or "minority report" pointing device @since 1.8 */
-#define ECORE_DEVICE_CLASS_WAND EFL_INPUT_DEVICE_TYPE_WAND /**< A synonym for ECORE_DEVICE_CLASS_POINTER @since 1.18 */
-#define ECORE_DEVICE_CLASS_GAMEPAD EFL_INPUT_DEVICE_TYPE_GAMEPAD /**< A gamepad controller or joystick @since 1.8 */
+#define ECORE_DEVICE_CLASS_NONE ECORE_INPUT_DEVICE_TYPE_NONE /**< Not a device @since 1.8 */
+#define ECORE_DEVICE_CLASS_SEAT ECORE_INPUT_DEVICE_TYPE_SEAT /**< The user/seat (the user themselves) @since 1.8 */
+#define ECORE_DEVICE_CLASS_KEYBOARD ECORE_INPUT_DEVICE_TYPE_KEYBOARD /**< A regular keyboard, numberpad or attached buttons @since 1.8 */
+#define ECORE_DEVICE_CLASS_MOUSE ECORE_INPUT_DEVICE_TYPE_MOUSE /**< A mouse, trackball or touchpad relative motion device @since 1.8 */
+#define ECORE_DEVICE_CLASS_TOUCH ECORE_INPUT_DEVICE_TYPE_TOUCH /**< A touchscreen with fingers or stylus @since 1.8 */
+#define ECORE_DEVICE_CLASS_PEN ECORE_INPUT_DEVICE_TYPE_PEN /**< A special pen device @since 1.8 */
+#define ECORE_DEVICE_CLASS_POINTER ECORE_INPUT_DEVICE_TYPE_WAND /**< A laser pointer, wii-style or "minority report" pointing device @since 1.8 */
+#define ECORE_DEVICE_CLASS_WAND ECORE_INPUT_DEVICE_TYPE_WAND /**< A synonym for ECORE_DEVICE_CLASS_POINTER @since 1.18 */
+#define ECORE_DEVICE_CLASS_GAMEPAD ECORE_INPUT_DEVICE_TYPE_GAMEPAD /**< A gamepad controller or joystick @since 1.8 */
/**
//typedef Efl_Input_Device_Subtype Ecore_Device_Subclass;
//
-#define ECORE_DEVICE_SUBCLASS_NONE EFL_INPUT_DEVICE_SUBTYPE_NONE /**< Not a device @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_FINGER EFL_INPUT_DEVICE_SUBTYPE_FINGER /**< The normal flat of your finger @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_FINGERNAIL EFL_INPUT_DEVICE_SUBTYPE_FINGERNAIL /**< A fingernail @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_KNUCKLE EFL_INPUT_DEVICE_SUBTYPE_KNUCKLE /**< A Knuckle @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_PALM EFL_INPUT_DEVICE_SUBTYPE_PALM /**< The palm of a users hand @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_HAND_SIZE EFL_INPUT_DEVICE_SUBTYPE_HAND_SIZE /**< The side of your hand @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_HAND_FLAT EFL_INPUT_DEVICE_SUBTYPE_HAND_FLAT /**< The flat of your hand @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_PEN_TIP EFL_INPUT_DEVICE_SUBTYPE_PEN_TIP /**< The tip of a pen @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_TRACKPAD EFL_INPUT_DEVICE_SUBTYPE_TRACKPAD /**< A trackpad style mouse @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_TRACKPOINT EFL_INPUT_DEVICE_SUBTYPE_TRACKPOINT /**< A trackpoint style mouse @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_TRACKBALL EFL_INPUT_DEVICE_SUBTYPE_TRACKBALL /**< A trackball style mouse @since 1.18 */
-#define ECORE_DEVICE_SUBCLASS_REMOCON EFL_INPUT_DEVICE_SUBTYPE_REMOCON /**< A remote controller @since_tizen 4.0 */
-#define ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD EFL_INPUT_DEVICE_SUBTYPE_VIRTUAL_KEYBOARD /**< A virtual keyboard @since_tizen 4.0*/
+#define ECORE_DEVICE_SUBCLASS_NONE ECORE_INPUT_DEVICE_SUBTYPE_NONE /**< Not a device @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_FINGER ECORE_INPUT_DEVICE_SUBTYPE_FINGER /**< The normal flat of your finger @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_FINGERNAIL ECORE_INPUT_DEVICE_SUBTYPE_FINGERNAIL /**< A fingernail @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_KNUCKLE ECORE_INPUT_DEVICE_SUBTYPE_KNUCKLE /**< A Knuckle @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_PALM ECORE_INPUT_DEVICE_SUBTYPE_PALM /**< The palm of a users hand @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_HAND_SIZE ECORE_INPUT_DEVICE_SUBTYPE_HAND_SIZE /**< The side of your hand @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_HAND_FLAT ECORE_INPUT_DEVICE_SUBTYPE_HAND_FLAT /**< The flat of your hand @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_PEN_TIP ECORE_INPUT_DEVICE_SUBTYPE_PEN_TIP /**< The tip of a pen @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_TRACKPAD ECORE_INPUT_DEVICE_SUBTYPE_TRACKPAD /**< A trackpad style mouse @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_TRACKPOINT ECORE_INPUT_DEVICE_SUBTYPE_TRACKPOINT /**< A trackpoint style mouse @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_TRACKBALL ECORE_INPUT_DEVICE_SUBTYPE_TRACKBALL /**< A trackball style mouse @since 1.18 */
+#define ECORE_DEVICE_SUBCLASS_REMOCON ECORE_INPUT_DEVICE_SUBTYPE_REMOCON /**< A remote controller @since_tizen 4.0 */
+#define ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD ECORE_INPUT_DEVICE_SUBTYPE_VIRTUAL_KEYBOARD /**< A virtual keyboard @since_tizen 4.0*/
typedef struct _Ecore_Device_Event_Info Ecore_Device_Event_Info; /**< @since 1.18 */
#include "ecore_private.h"
#define EFL_INTERNAL_UNSTABLE
-#include "interfaces/efl_common_internal.h"
+#include "ecore_input_device.eo.h"
/* WARNING: This API is not used across EFL, hard to test! */
ecore_device_add()
{
Ecore_Device *dev;
- Efl_Input_Device_Data *d;
- dev = efl_add_ref(EFL_INPUT_DEVICE_CLASS, NULL,
+ dev = efl_add_ref(ECORE_INPUT_DEVICE_CLASS, NULL,
efl_name_set(efl_added, NULL),
efl_comment_set(efl_added, NULL),
- efl_input_device_type_set(efl_added, EFL_INPUT_DEVICE_TYPE_NONE),
- efl_input_device_source_set(efl_added, NULL));
-
- d = efl_data_scope_get(dev, EFL_INPUT_DEVICE_CLASS);
- d->subclass = EFL_INPUT_DEVICE_SUBTYPE_NONE;
+ ecore_input_device_type_set(efl_added, ECORE_INPUT_DEVICE_TYPE_NONE),
+ ecore_input_device_subclass_set(efl_added, ECORE_INPUT_DEVICE_SUBTYPE_NONE),
+ ecore_input_device_source_set(efl_added, NULL));
_ecore_devices = eina_list_append(_ecore_devices, dev);
Eina_List *l, *l_next;
Ecore_Device *data;
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS);
EINA_LIST_FOREACH_SAFE(_ecore_devices, l, l_next, data)
{
EAPI Ecore_Device *
ecore_device_ref(Ecore_Device *dev)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS, NULL);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS, NULL);
return efl_ref(dev);
}
EAPI void
ecore_device_unref(Ecore_Device *dev)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS);
efl_unref(dev);
}
EAPI void
ecore_device_name_set(Ecore_Device *dev, const char *name)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS);
efl_name_set(dev, name);
}
EAPI const char *
ecore_device_name_get(const Ecore_Device *dev)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS, NULL);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS, NULL);
return efl_name_get(dev);
}
EAPI void
ecore_device_description_set(Ecore_Device *dev, const char *desc)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS);
efl_comment_set(dev, desc);
}
EAPI const char *
ecore_device_description_get(const Ecore_Device *dev)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS, NULL);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS, NULL);
return efl_comment_get(dev);
}
EAPI void
ecore_device_identifier_set(Ecore_Device *dev, const char *identifier)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS);
efl_comment_set(dev, identifier);
}
EAPI const char *
ecore_device_identifier_get(const Ecore_Device *dev)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS, NULL);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS, NULL);
return efl_comment_get(dev);
}
EAPI void
ecore_device_class_set(Ecore_Device *dev, Ecore_Device_Class clas)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS);
- efl_input_device_type_set(dev, clas);
+ ecore_input_device_type_set(dev, clas);
}
EAPI Ecore_Device_Class
ecore_device_class_get(const Ecore_Device *dev)
{
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS, EFL_INPUT_DEVICE_TYPE_NONE);
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS, ECORE_INPUT_DEVICE_TYPE_NONE);
- return efl_input_device_type_get(dev);
+ return ecore_input_device_type_get(dev);
}
EAPI void
ecore_device_subclass_set(Ecore_Device *dev, Ecore_Device_Subclass subclas)
{
- Efl_Input_Device_Data *d;
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS);
-
- d = efl_data_scope_get(dev, EFL_INPUT_DEVICE_CLASS);
- if (!d) return;
-
- d->subclass = subclas;
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS);
+ ecore_input_device_subclass_set(dev, subclas);
}
EAPI Ecore_Device_Subclass
ecore_device_subclass_get(const Ecore_Device *dev)
{
- Efl_Input_Device_Data *d;
- SAFETY_CHECK(dev, EFL_INPUT_DEVICE_CLASS, EFL_INPUT_DEVICE_SUBTYPE_NONE);
-
- d = efl_data_scope_get(dev, EFL_INPUT_DEVICE_CLASS);
- if (!d) return 0;
-
- return d->subclass;
+ SAFETY_CHECK(dev, ECORE_INPUT_DEVICE_CLASS, ECORE_INPUT_DEVICE_SUBTYPE_NONE);
+ return ecore_input_device_subclass_get(dev);
}
//
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Ecore.h"
+
+#define MY_CLASS ECORE_INPUT_DEVICE_CLASS
+
+typedef struct _Ecore_Input_Device_Data Ecore_Input_Device_Data;
+struct _Ecore_Input_Device_Data
+{
+ Eo *eo;
+ Ecore_Input_Device *source; /* ref */
+ Eina_List *children; /* ref'ed by efl_parent, not by this list */
+ Eina_Hash *grabs; /* Hash of all the object that might grab this device.
+ We expect thousand of them to be registered here,
+ that is why we use a hash. */
+ unsigned int id;
+ Ecore_Input_Device_Type klass;
+ unsigned int subclass;
+ unsigned int pointer_count;
+};
+
+typedef struct _Child_Device_Iterator Child_Device_Iterator;
+
+struct _Child_Device_Iterator
+{
+ Eina_Iterator iterator;
+ Eina_List *list;
+ Eina_Iterator *real_iterator;
+ Eo *object;
+};
+
+static Eina_Bool
+_is_pointer(Ecore_Input_Device_Data *pd)
+{
+ return (pd->klass == ECORE_INPUT_DEVICE_TYPE_MOUSE ||
+ pd->klass == ECORE_INPUT_DEVICE_TYPE_TOUCH ||
+ pd->klass == ECORE_INPUT_DEVICE_TYPE_PEN ||
+ pd->klass == ECORE_INPUT_DEVICE_TYPE_WAND);
+}
+
+static void
+_seat_pointers_update(Ecore_Input_Device_Data *seat, Ecore_Input_Device_Data *dev)
+{
+ if (seat && _is_pointer(dev))
+ seat->pointer_count++;
+}
+
+EOLIAN static Efl_Object *
+_ecore_input_device_efl_object_constructor(Eo *obj, Ecore_Input_Device_Data *pd)
+{
+ obj = efl_constructor(efl_super(obj, MY_CLASS));
+ pd->eo = obj;
+ return obj;
+}
+
+EOLIAN static void
+_ecore_input_device_efl_object_destructor(Eo *obj, Ecore_Input_Device_Data *pd)
+{
+ pd->children = eina_list_free(pd->children);
+ if (pd->klass != ECORE_INPUT_DEVICE_TYPE_SEAT)
+ {
+ Ecore_Input_Device_Data *p;
+ Eo *seat;
+
+ seat = ecore_input_device_seat_get(obj);
+ p = efl_data_scope_get(seat, MY_CLASS);
+ if (p) p->children = eina_list_remove(p->children, obj);
+ }
+ efl_unref(pd->source);
+
+ if (pd->grabs)
+ {
+ eina_hash_free(pd->grabs);
+ pd->grabs = NULL;
+ }
+
+ return efl_destructor(efl_super(obj, MY_CLASS));
+}
+
+EOLIAN static void
+_ecore_input_device_efl_object_parent_set(Eo *obj, Ecore_Input_Device_Data *pd EINA_UNUSED, Eo *parent)
+{
+ Ecore_Input_Device_Data *p;
+
+ if (parent)
+ {
+ if (efl_isa(parent, MY_CLASS))
+ {
+ p = efl_data_scope_get(parent, MY_CLASS);
+ EINA_SAFETY_ON_FALSE_RETURN(p->klass == ECORE_INPUT_DEVICE_TYPE_SEAT);
+ if (!eina_list_data_find(p->children, obj))
+ {
+ p->children = eina_list_append(p->children, obj);
+ _seat_pointers_update(p, pd);
+ }
+ }
+ }
+ else
+ {
+ Eo *old_parent = efl_parent_get(obj);
+ if (old_parent && efl_isa(old_parent, MY_CLASS))
+ {
+ p = efl_data_scope_get(old_parent, MY_CLASS);
+ p->children = eina_list_remove(p->children, obj);
+ if (_is_pointer(pd))
+ p->pointer_count--;
+ }
+ }
+
+ efl_parent_set(efl_super(obj, MY_CLASS), parent);
+}
+
+EOLIAN static void
+_ecore_input_device_device_type_set(Eo *obj, Ecore_Input_Device_Data *pd, Ecore_Input_Device_Type klass)
+{
+ EINA_SAFETY_ON_TRUE_RETURN(pd->klass);
+ pd->klass = klass;
+ if (klass != ECORE_INPUT_DEVICE_TYPE_SEAT)
+ {
+ Ecore_Input_Device_Data *seat = efl_data_scope_get(ecore_input_device_seat_get(obj), MY_CLASS);
+ _seat_pointers_update(seat, pd);
+ }
+}
+
+EOLIAN static Ecore_Input_Device_Type
+_ecore_input_device_device_type_get(const Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd)
+{
+ return pd->klass;
+}
+
+EOLIAN static void
+_ecore_input_device_source_set(Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd, Ecore_Input_Device *src)
+{
+ if (pd->source == src) return;
+ efl_unref(pd->source);
+ pd->source = efl_ref(src);
+}
+
+EOLIAN static Ecore_Input_Device *
+_ecore_input_device_source_get(const Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd)
+{
+ return pd->source;
+}
+
+EOLIAN static void
+_ecore_input_device_seat_id_set(Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd, unsigned int id)
+{
+ EINA_SAFETY_ON_TRUE_RETURN(pd->klass != ECORE_INPUT_DEVICE_TYPE_SEAT);
+ pd->id = id;
+}
+
+EOLIAN static unsigned int
+_ecore_input_device_seat_id_get(const Eo *obj, Ecore_Input_Device_Data *pd)
+{
+ if (pd->klass == ECORE_INPUT_DEVICE_TYPE_SEAT)
+ return pd->id;
+ return ecore_input_device_seat_id_get(ecore_input_device_seat_get(obj));
+}
+
+EOLIAN static Ecore_Input_Device *
+_ecore_input_device_seat_get(const Eo *obj, Ecore_Input_Device_Data *pd)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL);
+
+ if (pd->klass == ECORE_INPUT_DEVICE_TYPE_SEAT)
+ return pd->eo;
+
+ while ((obj = efl_parent_get(obj)))
+ {
+ if (!efl_isa(obj, MY_CLASS)) break;
+ pd = efl_data_scope_get(obj, MY_CLASS);
+ if (pd->klass == ECORE_INPUT_DEVICE_TYPE_SEAT)
+ return pd->eo;
+ }
+
+ return NULL;
+}
+
+static Eina_Bool
+_child_device_iterator_next(Child_Device_Iterator *it, void **data)
+{
+ Eo *sub;
+
+ if (!eina_iterator_next(it->real_iterator, (void **) &sub))
+ return EINA_FALSE;
+
+ if (data) *data = sub;
+ return EINA_TRUE;
+}
+
+static Eo *
+_child_device_iterator_get_container(Child_Device_Iterator *it)
+{
+ return it->object;
+}
+
+static void
+_child_device_iterator_free(Child_Device_Iterator *it)
+{
+ eina_iterator_free(it->real_iterator);
+ free(it);
+}
+
+EOLIAN static Eina_Iterator *
+_ecore_input_device_children_iterate(Eo *obj, Ecore_Input_Device_Data *pd)
+{
+ Child_Device_Iterator *it;
+
+ it = calloc(1, sizeof(*it));
+ if (!it) return NULL;
+
+ EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
+
+ it->list = pd->children;
+ it->real_iterator = eina_list_iterator_new(it->list);
+ it->iterator.version = EINA_ITERATOR_VERSION;
+ it->iterator.next = FUNC_ITERATOR_NEXT(_child_device_iterator_next);
+ it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_child_device_iterator_get_container);
+ it->iterator.free = FUNC_ITERATOR_FREE(_child_device_iterator_free);
+ it->object = obj;
+
+ return &it->iterator;
+}
+
+EOLIAN static int
+_ecore_input_device_pointer_device_count_get(const Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd)
+{
+ if (pd->klass == ECORE_INPUT_DEVICE_TYPE_SEAT)
+ return pd->pointer_count;
+ return -1;
+}
+
+EOLIAN static Eina_Bool
+_ecore_input_device_is_pointer_type_get(const Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd)
+{
+ return _is_pointer(pd);
+}
+
+EOLIAN static Ecore_Device_Subclass
+_ecore_input_device_subclass_get(const Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd)
+{
+ return pd->subclass;
+}
+
+EOLIAN static void
+_ecore_input_device_subclass_set(Eo *obj EINA_UNUSED, Ecore_Input_Device_Data *pd,
+ Ecore_Device_Subclass sub_clas)
+{
+ pd->subclass = sub_clas;
+}
+
+#include "ecore_input_device.eo.c"
--- /dev/null
+enum Ecore.Input.Device_Type
+{
+ [[General type of input device.]]
+ none, [[Not a device.]]
+ seat, [[The user/seat (the user themselves).]]
+ keyboard, [[A regular keyboard, numberpad or attached buttons.]]
+ mouse, [[A mouse, trackball or touchpad relative motion device.]]
+ touch, [[A touchscreen with fingers or stylus.]]
+ pen, [[A special pen device.]]
+ wand, [[A laser pointer, wii-style or "Minority Report" pointing device.]]
+ gamepad, [[A gamepad controller or joystick.]]
+}
+
+// TIZEN_ONLY(20171109): support a tizen_input_device_manager interface
+enum Ecore.Input.Device_Subtype
+{
+ [[General type of input device.]]
+ none, [[Not a device.]]
+ finger, [[The normal flat of your finger.]]
+ fingernail, [[A fingernai.]]
+ knuckle, [[A Knuckle.]]
+ palm, [[The palm of a users hand.]]
+ hand_size, [[The side of your hand.]]
+ hand_flat, [[The flat of your hand.]]
+ pen_tip, [[The tip of a pen.]]
+ trackpad, [[A trackpad style mouse.]]
+ trackpoint, [[A trackpoint style mouse.]]
+ trackball, [[A trackball style mouse.]]
+// TIZEN_ONLY(20170620): Add new device subclasses.
+ remocon, [[A remote controller.]]
+ virtual_keyboard, [[A virtual keyboard.]]
+//
+}
+//
+
+class Ecore.Input.Device extends Efl.Object
+{
+ [[Represents a pointing device such as a touch finger, pen or mouse.
+
+ @since 1.23
+ ]]
+ methods {
+ @property device_type {
+ [[Device type property]]
+ values {
+ klass: Ecore.Input.Device_Type; [[Input device class]]
+ }
+ }
+ @property subclass {
+ [[Device subclass property]]
+ values {
+ klass: Ecore.Input.Device_Subtype; [[Input device subclass]]
+ }
+ }
+ @property source {
+ [[Device source property]]
+ values {
+ src: Ecore.Input.Device; [[Input device]]
+ }
+ }
+ @property seat {
+ [[Get the @Efl.Input.Device that represents a seat.
+
+ This method will find the seat the device belongs to.
+
+ For this, it walk through device's parents looking for a device
+ with @Efl.Input.Device_Type.seat. It may be
+ the device itself.
+
+ In case no seat is found, $null is returned.
+ ]]
+ get {}
+ values {
+ seat: Ecore.Input.Device; [[The seat this device belongs to.]]
+ }
+ }
+ @property seat_id {
+ [[Seat id number
+ ]]
+ values {
+ id: uint; [[The id of the seat]]
+ }
+ }
+ children_iterate {
+ [[Lists the children attached to this device.
+
+ This is only meaningful with seat devices, as they are groups of
+ real input devices.
+ ]]
+ return: iterator<const(Ecore.Input.Device)> @move; [[List of device children]]
+ }
+ @property pointer_device_count {
+ [[The number of pointer devices in this seat.
+
+ Pointer devices are the ones whose @.device_type is $mouse, $pen, $touch or $wand.
+ In case this device is not of the type $seat, -1 is returned.
+ ]]
+ get {
+
+ }
+ values {
+ devices : int; [[The number of pointer devices.]]
+ }
+ }
+ @property is_pointer_type {
+ [[$true if @.device_type is $mouse, $pen, $touch or $wand.]]
+ get {
+
+ }
+ values {
+ pointer_type : bool; [[$true if the device has pointing capabilities.]]
+ }
+ }
+ }
+ implements {
+ Efl.Object.constructor;
+ Efl.Object.destructor;
+ Efl.Object.parent { set; }
+ }
+}
'efl_core_command_line.eo',
'efl_loop_timer.eo',
'efl_filter_model.eo',
+ 'ecore_input_device.eo',
]
foreach eo_file : pub_eo_files
'efl_core_env.c',
'efl_core_proc_env.c',
'efl_core_command_line.c',
+ 'ecore_input_device.c',
]
#<--TIZEN_ONLY
projects / platform / upstream / efl.git / commitdiff