Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
import efl_orientation;
|
2016-08-25 03:20:10 -07:00
|
|
|
import efl_input_types;
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
|
2016-08-30 22:24:14 -07:00
|
|
|
class Efl.Input.Pointer (Efl.Object, Efl.Input.Event, Efl.Input.State)
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
{
|
2016-08-23 02:12:10 -07:00
|
|
|
[[Event data carried over with any pointer event (mouse, touch, pen, ...)
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
|
|
|
|
@since 1.18
|
|
|
|
]]
|
|
|
|
methods {
|
|
|
|
@property action {
|
|
|
|
[[The action represented by this event.]]
|
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
act: Efl.Pointer.Action; [[Event action]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|
2016-08-23 02:12:10 -07:00
|
|
|
@property value_has {
|
|
|
|
[[$true if this event carries a valid value for the specified $key.]]
|
|
|
|
get {}
|
|
|
|
keys {
|
2016-11-07 03:07:28 -08:00
|
|
|
key: Efl.Input.Value; [[Pressed $key]]
|
2016-08-23 02:12:10 -07:00
|
|
|
}
|
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
has: bool; [[$true if input value is valid, $false otherwise]]
|
2016-08-23 02:12:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property value {
|
|
|
|
[[Represents a generic value for this event.
|
|
|
|
|
|
|
|
Refer to the documentation of @Efl.Input.Value for each value's
|
|
|
|
meaning, type and range. Call @.value_has.get to determine whether
|
|
|
|
the returned value is valid or not for this event.
|
|
|
|
|
|
|
|
Most values are precise floating point values, usually in pixels,
|
|
|
|
radians, or in a range of [-1, 1] or [0, 1]. Some values are
|
|
|
|
discrete values (integers) and thus should preferably be queried
|
|
|
|
with the other methods of this class.
|
|
|
|
]]
|
|
|
|
set {
|
|
|
|
return: bool; [[$false if the value could not be set (eg. delta).]]
|
|
|
|
}
|
|
|
|
get {}
|
|
|
|
keys {
|
2016-11-07 03:07:28 -08:00
|
|
|
key: Efl.Input.Value; [[$key]]
|
2016-08-23 02:12:10 -07:00
|
|
|
}
|
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
val: double; [[$key value]]
|
2016-08-23 02:12:10 -07:00
|
|
|
}
|
|
|
|
}
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
@property button {
|
2016-08-23 02:12:10 -07:00
|
|
|
[[The mouse button that triggered the event.
|
|
|
|
|
|
|
|
Valid if and only if @.value_has($button) is $true.
|
|
|
|
]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
values {
|
|
|
|
but: int; [[1 to 32, 0 if not a button event.]]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@property button_pressed {
|
2016-08-23 02:12:10 -07:00
|
|
|
[[Whether a mouse button is pressed at the moment of the event.
|
|
|
|
|
|
|
|
Valid if and only if @.value_has($button_pressed) is $true.]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
keys {
|
2016-11-07 03:07:28 -08:00
|
|
|
button: int; [[1 to 32, 0 if not a button event.]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
pressed: bool; [[$true when the button was pressed, $false otherwise]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property position {
|
2016-08-23 02:12:10 -07:00
|
|
|
[[Position where the event happened, relative to the window.
|
2016-05-30 20:15:25 -07:00
|
|
|
|
2017-09-18 04:42:52 -07:00
|
|
|
See @.precise_position for floating point precision (subpixel
|
|
|
|
location).
|
2016-05-30 20:15:25 -07:00
|
|
|
]]
|
|
|
|
values {
|
2017-09-18 04:40:53 -07:00
|
|
|
pos: Eina.Position2D; [[The position of the event, in pixels.]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|
2017-09-18 04:42:52 -07:00
|
|
|
@property precise_position {
|
|
|
|
[[Position where the event happened, relative to the window.
|
|
|
|
|
|
|
|
This position is in floating point values, for more precise
|
|
|
|
coordinates, in subpixels. Note that many input devices are unable
|
|
|
|
to give better precision than a single pixel, so this may be
|
|
|
|
equal to @.position.
|
|
|
|
|
|
|
|
See also @.position.
|
|
|
|
]]
|
|
|
|
values {
|
|
|
|
pos: Eina.Vector2; [[The position of the event, in pixels.]]
|
|
|
|
}
|
|
|
|
}
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
@property previous_position {
|
|
|
|
[[Position of the previous event, valid for move events.
|
|
|
|
|
2016-08-23 02:12:10 -07:00
|
|
|
Relative to the window. May be equal to @.position (by default).
|
|
|
|
|
|
|
|
This position, in integers, is an approximation of
|
|
|
|
@.value.get($previous_x), @.value.get($previous_y).
|
|
|
|
Use @.previous_position if you need simple pixel positions,
|
|
|
|
but prefer the generic interface if you need precise coordinates.
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
]]
|
|
|
|
values {
|
2017-09-18 04:40:53 -07:00
|
|
|
pos: Eina.Position2D; [[The position of the event, in pixels.]]
|
2016-05-30 20:15:25 -07:00
|
|
|
}
|
|
|
|
}
|
2016-08-23 02:12:10 -07:00
|
|
|
@property tool {
|
|
|
|
[[ID of the tool (eg. pen) that triggered this event.]]
|
2016-05-10 05:26:07 -07:00
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
id: int; [[Tool ID]]
|
2016-05-10 05:26:07 -07:00
|
|
|
}
|
|
|
|
}
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
@property source {
|
|
|
|
[[The object where this event first originated, in case of
|
|
|
|
propagation or repetition of the event.
|
|
|
|
]]
|
|
|
|
values {
|
2016-08-10 07:23:04 -07:00
|
|
|
src: Efl.Object; [[Source object: $Efl.Gfx]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property button_flags {
|
|
|
|
[[Double or triple click information.]]
|
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
flags: Efl.Pointer.Flags; [[Button information flags]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|
2016-05-30 21:40:14 -07:00
|
|
|
@property double_click {
|
|
|
|
[[$true if @.button_flags indicates a double click (2nd press).
|
|
|
|
|
|
|
|
This is just a helper function around @.button_flags.
|
|
|
|
]]
|
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
val: bool; [[$true if the button press was a double click, $false otherwise]]
|
2016-05-30 21:40:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property triple_click {
|
|
|
|
[[$true if @.button_flags indicates a triple click (3rd press).
|
|
|
|
|
|
|
|
This is just a helper function around @.button_flags.
|
|
|
|
]]
|
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
val: bool; [[$true if the button press was a triple click, $false otherwise]]
|
2016-05-30 21:40:14 -07:00
|
|
|
}
|
|
|
|
}
|
2017-08-09 05:04:10 -07:00
|
|
|
@property wheel_horizontal {
|
|
|
|
[[Direction of the wheel, usually vertical.]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
values {
|
2017-08-09 05:04:10 -07:00
|
|
|
horizontal: bool(false); [[If $true this was a horizontal wheel.]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|
2016-08-23 02:12:10 -07:00
|
|
|
@property wheel_delta {
|
|
|
|
[[Delta movement of the wheel in discrete steps.]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
values {
|
2016-11-07 03:07:28 -08:00
|
|
|
dist: int; [[Wheel movement delta]]
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
implements {
|
2016-08-10 07:23:04 -07:00
|
|
|
Efl.Object.constructor;
|
2016-08-10 02:59:36 -07:00
|
|
|
Efl.Object.destructor;
|
2016-05-10 05:26:07 -07:00
|
|
|
class.destructor;
|
2016-08-25 03:20:10 -07:00
|
|
|
Efl.Input.Event.reset;
|
2017-11-29 03:03:16 -08:00
|
|
|
Efl.Dup.dup;
|
|
|
|
[[Creates a copy of this event. @Efl.Input.Event.fake is $true.
|
|
|
|
|
|
|
|
The returned event object is similar to the given object in most
|
|
|
|
ways except that @Efl.Input.Event.fake will be $true.
|
|
|
|
|
|
|
|
Note: A reference is given to the caller. In order to avoid leaks
|
|
|
|
the C API users should call $efl_unref() after use.
|
|
|
|
]]
|
2016-12-27 07:37:41 -08:00
|
|
|
Efl.Input.Event.timestamp { get; set; }
|
|
|
|
Efl.Input.Event.fake { get; }
|
|
|
|
Efl.Input.Event.event_flags { get; set; }
|
|
|
|
Efl.Input.Event.device { get; set; }
|
|
|
|
Efl.Input.State.modifier_enabled { get; }
|
|
|
|
Efl.Input.State.lock_enabled { get; }
|
Efl: Add storage class Efl.Pointer.Event
This object is the data carried over in an event data pointer.
The private data should be accessible by Ecore and Evas, but
not externally. This means we should be able to easily extend
the feature set, adding more and more information, without
breaking API / ABI.
Also, this should allow applications to create fake input
events easily without exposing our internal structures, or
functions with more and more parameters (such as feed multi).
This is only a storage class, shouldn't contain any logic.
In the future, some logic may be added for gestures support
for instance, or input smoothing / resampling (eg. if input
frequency is 90Hz and screen refresh rate is 60Hz).
The aim is to replace:
- Evas_Event_Mouse_Xxx
- Evas_Event_Multi_Xxx
- Ecore_Event_Mouse_Xxx
We might want to also support Axis, Gestures, etc... with the
same model or even same storage class.
2016-04-28 01:31:46 -07:00
|
|
|
}
|
|
|
|
}
|