Summary:
The internal and the API we would like is mostly a canvas API. A lot of the code
in evas is working around the fact that efl_input_device is not defined inside Evas.
This patch is the first step to try to clean this up.
Depends on D10487
Reviewers: zmike, raster, bu5hm4n, Hermet
Reviewed By: zmike
Subscribers: #reviewers, #committers
Tags: #efl
Maniphest Tasks: T8321
Differential Revision: https://phab.enlightenment.org/D10488
Summary:
Efl.Gfx.Vg.Value_Provider is an object for integrating and managing the properties of vector objects.
These values are dependent on the keypath.
Keypath is the target a specific content or a set of contents that will be updated.
It can include the specific name of the contents, wildcard(*) or Globstar(**).
The valueProvider is borrowed from another library that uses a vector object of type json, such as Efl.Ui.Animation_View
(5fc0e59e0c/lottie-swift/src/Public/iOS/AnimatedControl.swift (L50))
This feature should be used with some patches that apply to the vg json loader and Efl.Canvas.Vg.Object.
Test Plan: N/A
Reviewers: Hermet, kimcinoo, smohanty
Reviewed By: Hermet
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9874
Summary:
Implements a vector class that can support image.
User can use this class to output an image with a vector object.
Depends on D9218:Ector.Renderer : Implement Ector.Renderer.(Software).Image class
Test Plan: N/A
Reviewers: Hermet, smohanty, kimcinoo
Reviewed By: Hermet
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9219
Summary:
https://phab.enlightenment.org/T7544
Provides a way for a user to get a gesture manager, recognizer instance.
Supports different recognizer properties for each target(Eo).
Gesture, Touch Class Life-cycle re-implementation. for supporting multiple touches.
Add below gestures.
efl_canvas_gesture_tap
efl_canvas_gesture_double_tap
efl_canvas_gesture_triple_tap
efl_canvas_gesture_long_tap
efl_canvas_gesture_momentum
efl_canvas_gesture_zoom
efl_canvas_gesture_flick
Test Plan:
Simple test -> test_gesture_framework.c
More test cases will upload.
Reviewers: woohyun, smohanty, segfaultxavi, Jaehyun_Cho
Reviewed By: Jaehyun_Cho
Subscribers: Jaehyun_Cho, segfaultxavi, cedric
Tags: #efl, #do_not_merge
Differential Revision: https://phab.enlightenment.org/D7579
Summary:
Since we're now going to be shipping some eo classes as stable,
there is no point in keeping the eo api behind a macro, and it
should be enabled by default. Another case is beta classes, but
those are behind the EFL_BETA_API_SUPPORT guard.
This also changes includes around the place where things are
clearly broken (such as an included header needing something
from another header but that other header being guarded, notably
efl_ui_widget.h needing focus manager but focus manager being
behind beta in Elementary.h)
Reviewers: zmike, cedric, bu5hm4n, stefan_schmidt, segfaultxavi
Reviewed By: cedric, segfaultxavi
Subscribers: segfaultxavi, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D8322
Summary:
For clarity, since there are all kinds of maps, including a navigation map
widget.
Also, corrected some misspellings.
Test Plan: make && make check && make examples all work
Reviewers: cedric, zmike, bu5hm4n
Reviewed By: cedric
Subscribers: Jaehyun_Cho, #reviewers, #committers
Tags: #efl
Maniphest Tasks: T7564
Differential Revision: https://phab.enlightenment.org/D7974
This reverts commit ae65c64b8d.
It appears that abstract -> abstract enforcement is not needed anymore,
the other patches are fine. However, this one proposes a new object
which is not needed to exist.
Reviewed-by: Xavi Artigas <xavierartigas@yahoo.es>
Differential Revision: https://phab.enlightenment.org/D7676
the efl_canvas_group should be abstract in order to support other
classes which are inheriting from it, which are abstract. This is done
in order to support only abstract parents from abstract classes.
ref T7240
Reviewed-by: Xavi Artigas <xavierartigas@yahoo.es>
Differential Revision: https://phab.enlightenment.org/D7600
Summary:
Following our naming rule, rename to like other primitives.
i.e. efl_canvas_rect, efl_canvas_image, efl_canvas_vg ...
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D7013
Change name of animation event info to synchronize with other event
info names.
Change data name in animation event info to synchronize with data type
name, Efl.Event.Description.
To synchronize other types of event info,
Efl_Canvas_Animation_Player_Running_Event_Info is changed to
Efl_Canvas_Animation_Player_Event_Running.
Remove unused struct.
This interface has a simple 'create' method to create Efl.Canvas.Object
given a key.
This is used higher-up in Ui.Text in the next commit.
Ui text: add ability to set item factories
Added API to set an item factory object.
This is similar to the previous item providers (that worked with
callbacks).
You instantiate a factory object and set it on the Ui.Text object.
Each factory implements the "create" method from
Efl.Canvas.Text.Item_Factory.
This also includes 3 public factories (Image, Emoticon and Fallback):
- Image factory: creates images from added entries (key strings)
- Emoticon factory: creates emoticons by querying the theme
- Fallback: creates image, then falls back to emoticon
If no factory is set, then the fallback (internal) factory is used.
See the added "Ui.text Item Factory" test in elementary_test for an
example of usage.
@feature
Summary:
Efl.Player interface simply provides play functions,
but another interface which indicates Efl.Player will play is also
needed.
Test Plan: Run elementary_test->Efl.Animation tests
Reviewers: woohyun, conr2d, Jaehyun_Cho, jpeg, cedric
Differential Revision: https://phab.enlightenment.org/D5662
This isn't meant to be installed. The canvas API in EO is based around
the interfaces Efl.Canvas and the widget Efl.Ui.Win. Anything else is
not EO (eg: ecore_evas, evas, ...)
Note: evas_canvas3d is the last remaining thing that is installed along
EO files, but those are all beta APIs.
Efl.Animation.Group.Sequential is a class for animations started in
sequence.
Efl.Animation.Object.Group.Sequential is a class which provides
methods for an object of Efl.Animation.Group.Sequential.
The objects added into the sequential group animation object start
in sequence.
Efl.Animation.Group.Parallel is a class for animations started in
parallel.
Efl.Animation.Object.Group.Parallel is a class which provides methods
for an object of Efl.Animation.Group.Parallel.
The objects added into the parallel group animation object start in
parallel.
Efl.Animation.Object is a class which starts or cancels animation.
Efl.Animation.Object instance is created by Efl.Animation instance.
So Efl.Animation.Object instance contains animation properties from
Efl.animation instance.
Animation properties are set by using Efl.Animation instance and the
animation is started or cancelled by using Efl.Animation.Object.
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
adding an "event rect" is a common use case for rectangles, but I needed
a smarter event rect so I sent one off to school and it came back like this.
an event_grabber is a smart object which functions like a normal event rect
which has color(0,0,0,0), but with an important difference: it can have smart
members. event propagation works differently for an event_grabber:
normal:
event -> layer -> smart(obj1,obj2,obj3) ->(?) other objects
in this case, obj1,obj2,obj3 are all "inside" the smart object and their stacking
will always be considered as being inside the smart object. rendering is also
tied to the smart object in this case, as is clipping.
an event which reaches a smart object will be sent to the objects inside,
and then may continue through the smart object if there are no objects which
block repeating.
event_grabber:
event -> layer -> event_grabber -> obj1,obj2,obj3 -> STOP
in this case, obj1,obj2,obj3 are unmodified after being added to the event_grabber
and can be stacked, rendered, and clipped completely independently of the
event_grabber.
the event_grabber is considered an "event_parent" for this case. member objects
are not "inside" the event_grabber, and they are unable to receive events on
their own. instead, the event_grabber, which must be stacked above all its
members, receives events and propagates them top->down through its member objects.
if none of the member objects block the repeat of an event then the event will
still be blocked from further propagation past the event_grabber.
object lifetimes are independent of the event_grabber; deleting the event_grabber
has no effect on its members.
@feature
Summary:
Cleans up grammar, simplifies wording, and elaborates on some details
for better clarity. Assume the reader will already have a basic
understanding of reference counting and 3D graphics in order to avoid
overexplaining these concepts.
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4837
Cedric Bail
junsu choi
WooHyun Jung
Woochanlee
Daniel Kolesa
Xavi Artigas
Marcel Hollerbach
Hermet Park
Jaehyun Cho
Mike Blumenkrantz
Daniel Hirt
Sungtaek Hong
Jean-Philippe Andre
subhransu mohanty
smohanty
Daniel Zaoui
Amitesh Singh
Bryce Harrington