Summary:
When multi down or multi move occur, state of touch point changes to EVAS_TOUCH_POINT_STILL.
So I add condition, "state == EVAS_TOUCH_POINT_STILL"
Reviewers: jypark, woohyun, cedric
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D5157
Summary:
If the object is outside the parent geometry because of map,
this object would be ignored in determining object is in the event area.
Please refer to below case
1) There are some button in the box object
2) A button has map with 90 degree.
It would be placed outside the box geometry
3) If you press the button part outside the box,
the button event does not work.
Test Plan: sample code
Reviewers: jpeg, cedric
Differential Revision: https://phab.enlightenment.org/D5180
This fixes scrolling in rage.
Lessons learnt:
- Do not trust raster's bisecting skills ^^,
- Do not blame GCC until you're 100% positive about the exact code
triggering an issue,
- va_arg is unsafe, and can lead to crazy issues like this one,
- va_arg passes (int x, int y) differently from Eina_Size2D sz, and
optimization flags may also affect how that's done, or at least what
kind of garbage data is used.
For this patch I decided to add a pseudo legacy wrapper as the function
is called in a very large number of places. Fixing all those calls to
use the size2d form is a lot of work and a greater risk of b0rking
something.
It's a complex struct but defined in EO as a simple struct. ABI-wise
it's equivalent to Eina_Rectangle. Some macros that use Eina_Rectangle
also work on Eina_Rect out of the box, most of the code dealing with
x,y,w,h will require no modifications either.
But Eina_Rect provides direct access to a size or position 2d component,
as well as the usual x,y,w,h. The field "rect" is provided as a
convenience for code dealing with both Eina_Rectangle and Eina_Rect. We
may or may not require it.
Note: Size2D could use unsigned values but I have spotted a few places
in the code that actually use -1 to indicate invalid size (as opposed to
0x0).
@feature
this has affected edje for... like... ever. min size of boxes just
doesnt work. because evas box just doesnt do it right. this has led to
nasty things where edje box is just not usable if you use weight of 0.
btw weight 0 means "stay at min size no matter what even if we expand
the box to be bigger" in edje... which is totally broken and i can't
fix that without potentially breaking even more stuff... but let's
see. i've been using this for several days now and ... i can't find
breakage... so this should fix up SOME issues in edje.
@fix
This API was introduced in commit:
cd3f8db506
This was since limited to EO only APIs, and totally underexploited.
After that, efl_part() was introduced, which defines how all part APIs
should be designed.
Nothing uses this API, efl_vg had an implementation that provides no
extra value over the other APIs.
This changes the CRI logs and the variable names.
I still think this API needs some fixing in order to not abuse the
smart object API. This should be done before it's too late (i.e. E is
released and depends on it).
This is a new function that indicates whether an object is a child of a
parent or not. Dead simple, as this simply compares if parent == this.
Note that this check was impossible to do with the event grabber.
Also, rename group_children_iterate to group_members_iterate for
consistency with the other group_member functions.
@feature
Inside emotion, if Eio is compiled, some asynchronous functions are used
and a refcounted struct was used to ensure safety of the code.
Unfortunately the logic didn't make much sense as emotion's private data
is used. The refcount becomes useless, the lifecycle of the data being
bound to the object itself.
Note that an actual crash is almost impossible because:
- eio is actually quite fast
- evas objects are kept alive for 2 frames
- eina_freeq is used to keep eo objects' data alive for some more time
But this in theory fixes the events, as they were sent on the wrong
object. "obj" is the image object, "smartobj" was the emotion object.
This is fixed with a weak ref.
I don't think it is necessary to backport this.
It's not exposing anything that wasn't already accessible before (you
could just add a member and get its clip, for instance).
This will be used by Edje Object.
This is a minor
@feature
- color_set
- visible_set
- position_set
- no_render_set
- member_add, member_del
- group_add, group_del
- clip_set
Notes:
- Widget overrides color_set without calling super() which means that
color_get() returns a different value. Also any subsequent child
object add will not inherit the color.
- Smart clipped objects also don't call super.
This patch changes that, but only for smart clipped objects created
through EO. This shouldn't have any side effect.
Introduction to the problem:
- Efl.Canvas.Group has a method member_add() to add sub objects.
- Efl.Canvas.Group (simple smart object) does NOT actually delete the
objects on deletion. But:
- Efl.Canvas.Group.Clipped is a direct subclass and WILL delete the sub
objects on deletion.
Semantically, all smart objects (at least in EO and Elementary) will own
and delete sub objects automatically. Some exceptions are:
- Edje object (smart clipped) does not delete swallowed objects.
Edje object is a "clipped" smart object but it pops out all swallowed
children before getting deleted.
- Evas box/table/grid also pop out their children before deletion.
Those classes are all legacy & internal only.
- Elm.Widget will "manually" delete all its sub objects at deletion, as
it inherits from Efl.Canvas.Group but basically takes full ownership
of the sub objects. Note that member_add shouldn't be used on a
widget, the widgets do it themselves.
Also, smart clipped objects are much more convenient to use as they will
handle some things for you: color, visibility, moving and ownership.
So, the API member_add needs to be marked as own(). But right now
Efl.Canvas.Group does not own. Thus, here's the plan:
- Mark clipped objects as such with an internal API
- Merge clipped smart object features directly inside the standard
smart object.
- Get rid of Efl.Canvas.Group.Clipped entirely and watch all hell break
loose.
Ref T5301
This is an attempt at fixing crashes in empc.
Test scenario:
ELM_ACCEL="" elementary_test -to "Gfx Filters"
And mouse scroll like crazy in the spinner.
@fix
a canvas can have multiple objects with the same name. assuming that name:obj
is a 1:1 ratio means that name-finding functions are likely to return invalid
objects
@fix
evas_textgrid_cellrow_get() is supposed to return NULL if the row index
fed to the function is outside of the textgrid's range. It was instead
returning garbage pointer.
@fix
This fixes a case where an object is hidden before the first render.
When called from elementary. the visible intercept code would be called
before evas object's visible_set, bypassing the line setting visible_set
to true.
As a consequence the object would be visible even when explicitly
requested as hidden.
Thanks @JackDanielZ for the report!
For now, do not use Evas_Canvas3D in multi output context, it won't work.
The update code for Evas_Canvas3D_Node might trigger rendering logic, which
is opposite to what the scene graph logic should do. It require to much
reshuffle around to handle that case at the moment. So I am just adding a
warning.
The 'c->w' field gets manipulated for querying cutoffs of text with its
boundaries. Better to keep it a read-only field, to reduce confusion.
Also updated querying internal functions for better readability.
This is a semi experimental patch to set the default weight
of objects to (1, 1), i.e. EXPAND. This seems like a more
sensible default value than no weight. Some objects may not
need the expand weight, but this seems to be the minority,
not the majority.
Ref T5301
This is to pretend the object is visible when it's been added with
efl_add but evas hasn't started rendering yet (it's in the queue).
This code is not enabled (yet?) although I think it could very well be
(I don't observe the same bugs as I did the first time I tried this
patch).
Objects show should happen as early as possible during the render cycle,
as it affects smart objects calculation and everything else.
Thanks @JackDanielZ for the report!
Fixes T5880
So, this is maybe not the best fix. The question is should we be able to
get efl_data_scope_safe_get return the object private data, when we are
currently executing the object EFL_EVENT_DEL callbacks. Right now we don't
and this lead to bug where we wouldn't have been able to destroy a callback
and get that callback triggered later on destroyed data (I had a crash in
terminology). I have switched back to the not _safe_ version which doesn't
enforce this, but that might not be the only place that need a fix.
Somehow starting VirtualBox would crash E when trying to upload invalid
data. I believe checking for NULL data here is all we need to do in
order to keep the image data consistent and valid.
I have to admit I'm not 100% sure what is happening here.
Fixes T5868
@fix
This is really only a demonstration of what kind of information
we can print with efl_debug_name_get(). Hopefully this can help
debugging with printf/ERR logs and even help with live debugging
inside gdb.
This shouldn't be used for other purposes than debugging, as the
exact string format is not defined.
@feature
All legacy objects remain invisible by default. Any call to
visible_set() will prevent the automatic show() to happen.
show() will be done just before render time, which may be a
bit too late in order to propagate the necessary changes.
This may break some things where some objects are created
internally using efl_add() instead of the legacy API, and
the intent was not to show the object.
@feature
Summary:
If user use the evas_object_smart_callback_add with no smart object,
it should be returned
@fix
Test Plan: self
Reviewers: jpeg, cedric, jypark
Differential Revision: https://phab.enlightenment.org/D5056
This reverts commit 936ea58cb9.
this is an ideal change, but it breaks previously-expected behaviors
for interceptors and thus enlightenment is completely broken
eina_list_free always returns NULL. it's meant as a design pattern to
follow like the append/prepend that ensures a freed list is NULL, but
it can be confusing to analysers so remove the assing. not a bug
actually.
found by PVS studio
this fixes a bit wraparound in the shift as the 1 is an int (32bit)
type that then gets shifted .. then after that cast to 64bit.
found by PVS studio
@fix
Some objects don't go through render_pre (unchanged, child
of mapped parents), even though they will go through
evas_render_mapped. Those were marked as pre_render_done
inside evas_render_mapped since it seemed to fix some issues
a long time ago.
Unfortunately, if those objects are changed their flag may
not be reset to false, which means they never go through
render_pre, leading to render issues.
I believe simply restoring the value of the pre_render_done
flag should be good enough. I don't know why it is set to
true inside evas_render_mapped but I also don't want to find
out :)
See 9ac13e4aec (old)
See 87e5e70a9d (older)
Patch made with @jiin.moon
If an object fails to call efl_destructor() on all the parent
classes, then it may never be removed from the layer object
inlist and never would its data be deleted either (eo keeps
it safely alive).
Here's how to test: add a "return;" statement inside an object's
destructor (eg. the window class).
Fixes T5680
evas_object_image_data_get() is a legacy API that I made work
with snapshot objects (evas_object_image_snapshot_set()). Some
changes in the engine broke the behaviour and this patch fixes
it.
When getting the pixels from an FBO, in read-only mode, we need
to create a temporary image (pixels surface) that contains the
copy of the pixels we get from glReadPixels. This image needs
to be deleted afterwards. It is thus stored by the image object
and freed upon _image_data_set() (good) or object deletion (bad).
FBO + read-write is not supported by this API (it is supported
through buffer_map as the filters had to use that).
Fixes T5754
Changes cursor handle name from 'Efl.Text.Cursor.Cursor_Data' to
'Efl.Text.Cursor.Cursor'.
Also, replace all usages of Efl_Canvas_Text_Cursor
with Efl_Text_Cursor_Cursor as the handle for the cursor.
this should fix T5582 "properly" by emitting a move after an in only
if pointer x,y changed. this fixes rage and i hope still should handle
the original issue. let me know if it doesn't.
@fix
Summary:
If there are appended font pathes before initializing Fontconfig,
Evas must care the font pathes after initializing Fontconfig.
@fix
Test Plan:
1. Call evas_font_path_global_append() with a private font path
before adding any Evas Object.
2. Add a Evas Textblock object which uses a font from the private font path.
3. See the font is not loaded properly without the patch.
Reviewers: raster, cedric, herdsman, jpeg, woohyun
Differential Revision: https://phab.enlightenment.org/D4867
When using the legacy API (and in fact also with the EO API) to
listen to mouse events (move, in, out...) on a window instead
of an actual evas object, some information was missing:
- buttons (bitmask of pressed buttons)
- prev.x/y (previous position)
This is because Evas had not handled the event yet at this
point, it was coming directly from ecore_evas with incomplete
information. This patch involves evas a little bit earlier, and
also fixes evas_events_legacy.c to have consistent values for
cur/prev canvas/ouput coordinates. See also 890a91785 and
484dae76e6. Those commits were making the pointer coord
a seat-based property (instead of canvas-based) but the event
should already have those proper values before converting to
a legacy struct. This patch restores the meaning of the DUP
macros, as I observed 4 different coordinates from the app side
(instead of just 2: prev and cur).
Thanks to Andy for reporting the original issue on the ML!
I could not reproduce it but the case should not happen,
so I'm adding a safety check rather than a silent return.
The private data should be NULL only after evas_object_free()
or before construction...
Fixes T5656
For some reason, c39855a8ac also seems to
address an issue with height calculations (although not mentioned in
the commit message).
It already went in v1.19, so by applying
b8beb6834b I also reverted that behavior.
Seems like a correct one, so re-applying.
Fixes T5594
This is a very simple proof of concept for using hardware planes for
evas image objects.
Right now only dmabuf objects will be dropped into planes, and they're
considered in the order they're in in the scene graph with no attention
paid to which objects will have the most benefit from being on a plane
at all. There's nothing to prevent your mouse cursor from consuming the
only hardware plane capable of UHD video. :)
This is mostly just to help test the low level functionality in the
engines and ecore_drm2 that enable hardware planes. Smarter plane usage
is coming.
Add functions for assigning hardware planes to evas image objects.
The unfortunate asymmetry of the code is due to plane assignment being
only fully verifiable by doing a test commit through ecore_drm2, so it's
simpler to have the "test" function also do the "assignment", and call
the release on failure to clean up after a failed test.
If an evas object is a wayland dmabuf, uses native surface 5 or higher,
and has a scanout handler set, then it meets the basic requirements for
placing on a hardware plane.
Need to handle this with special care as Efl.Text.Cursor is used in
some functions that are specific to Efl.Canvas.Text, was well as
functions in Efl.Text.Cursor interface.
Value-based alignment (e.g. 0.5, 0.3 etc) isn't very practical.
Horizontal and vertical alignments will be assigned with enums
"left", "center", "right", "auto", "locale", for horizontal alignment,
and "top", "center" and "bottom" for vertical alignment.
This changes the previously added "halign" and "valign" properties.
with async device init, it's possible for mouse in/out/move events to be added
by an application before the pointer devices are created. these are independent
of devices, so store the state and apply when pointer devices are added
fix T5531
There is a mismatch between seat & pointer.
See @zmike's comments in T5515. Having both seat and pointer
devices as different devices leads to these kinds of issues.
Really annoying.
Ref T5515
This enables some insane debugging for input events inside evas.
Also, declutter the code by always providing the "spaces" variable.
Obviously this is not enabled :)
Example, without any running wayland compositor:
ELM_DISPLAY=wl runsomeapp
elm_win runs efl_constructor() during finalize() which is wrong
and leads to this kind of inconsistencies. Urgh.
Summary:
There are many requests to add a new feature for handling horizontal align
according to current locale. For example, in RTL locale setting,
users want to see right aligned text for every list's item.
Even if some of list's items only contain LTR characters!
It is useful for the needs.
@feature
Test Plan: N/A
Reviewers: herdsman, tasn, woohyun, raster, cedric
Reviewed By: herdsman, raster
Subscribers: z-wony, jpeg
Differential Revision: https://phab.enlightenment.org/D4664
After finalize, the type of an input device can not be changed.
So, deprecate the function and prevent anything from happening
unless we're inside efl_add().
Ref T5515
Eina_Clist can actually change the pointer in the cell next bypassing
the CoW infrastructure leading to trouble. Considering the case here,
using the optimization of Eina_Clist is not necessary and if performance
issue arise, can be fixed by using a dichotomic search when removing
data. I don't think it is necessary to add this complexity without
a real life case.
Thanks @zmike for the report.
This in therory should restore behaviour from 1.18,
where the intercept function is called even if the geometry
isn't changed.
Test scenario, in E:
1. remove bryces, shelves on a screen, or mark all as autohide
2. open chromium or any CSD application as unmaximized
3. maximize the window
4. make it fullscreen (eg. with chromium: F11)
See 8a9f0bd603.
Ref T4749
Fixes T5573
@fix
This reverts commit f69686ba40.
this causes major crashes in e every time you move and resize a
window. i cant even debug it properly because i cant move or resize
windows to get terminals up to debug it... this is bad... so until a
fix is found better to go back to working...
Summary: Before the value of stride is calculated, the weight and height of the rotated image should be set.
Test Plan: {F1409510}
Reviewers: jpeg
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4955
Signed-off-by: Cedric Bail <cedric@osg.samsung.com>
During a window destruction, the input devices are deleted and
removed from the internal devices list. Since 83d18617b4
basic devices are children of a seat, which means that the seat
deletion was triggering the devices deletion as well. As a
consequence, we were walking an invalid list of devices.
I'm not sure we should have a list of children in the device
data and I'm also not sure we should have a list of devices in
evas, instead of just the list of seats. It's a bit messy right
now.
Ref T5540
1. The word "class" is a pain point with many languages where
it's a keyword. Type is a little better. Also, the property
was already named "device_type" and not "device_class".
2. Remove Efl.Input.Device.Sub_Class
It's not used inside EFL upstream codebase, and unlikely to
be used anywhere else (even in Tizen).
Hopefully no one used the Efl_ enum types. So far only the Evas_
types should be in used.
Ref T5540
Those are now merged with Efl.Object parent, name and comment.
The reasoning is that only seats can be parent devices; And name
and description are not only name clashes but also not extremely
useful anyway.
Tested with VNC.
Fixes T5540
eo_prefix are set to "efl_text".
Also, "Efl.Text.Format" is shortened to now include the "_format"
prefix.
"Efl.Text.Font" keeps the "_font" prefix, for better readability.
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
This patch adds support for map with more than 4 points.
However, we only support points with multiples of 4.
This also adds efl_gfx_map_point_count_set/get APIs to
set number of points.
@feature
See also eb27724eb9 which didn't fix
the reported issue. Not quite sure yet how to implement those
lock & modifiers for fake events (i.e. artificially created
by the app itself).
Fixes T5510
This size hint is only used by naviframe, which is not part of
our EO widgets. I also believe it might be an even more confusing
hint than the others.
I kept the typedef as is in Evas_Legacy.h in case an app is
written using EFL_GFX_ instead of EVAS_...
This moves all part_drag APIs to legacy and implements them for
EO using efl_part(). All parts now support these APIs, even if
they are not draggable. Making this more fine grained would
probably be much extra work for little gain.
This creates a new interface Efl.Ui.Drag.
Summary:
map_surface does not redraw in below case.
1) parent and child are smart object and has map.
3) drawing objects.
4) apply new map to child object.
Test Plan: sample code
Reviewers: jpeg, cedric, jypark
Differential Revision: https://phab.enlightenment.org/D4889
this is still semi-broken if a seat has many pointer-ish type devices since
pointer devices in ecore-evas were never correctly implemented to be 1:1 with
seat:cursor relationships
@feature
Fixes mouse name that was "keyboard".
This is an attempt at unifying names under X11, WL and VNC.
The default device names now look the same, namely "Keyboard"
and "Mouse". The default seat still has different names on WL
and X11 ("seat-0" and "default").
Following a remark in the mailing list, it is pretty clear that
Efl.Gfx.View.view_size is not as simple as "image_size".
I have defined this new image_size as being the size of the
image file, and not what's currently loaded. So it will not
apply to proxies, gl views, 3d scenes, etc... but only to
standard image files loaded with file_set or mmap_set.
Supported objects:
- Efl.Canvas.Image (evas image)
- Efl.Ui.Image (elm image)
- Elm.Photocam (note: still needs some interface work)
@feature
The COW object may have not been created if the object could
not be created. Example: a window failed to open because the
engine could not create a surface.
This reverts commit 0a28cb97af, as the
addressed issue was still occurring.
Non-dirty paragraphs were not considered when recalculating the
formatted width of the text.
This could easily be reproduced with two paragraphs, getting the width,
and then updating only the second paragraph.
Added a test case.
@fix
Revert "Revert "evas: Fix build for Windows (hopefully)""
This reverts commit c8ec1cb2af.
The two efl_input_ functions need to be declared as EOAPI inside
the file where they are implemented. Otherwise the symbols aren't
exposed and weak linking means the function call crashes.
Sorry for the first untested patch and subsequent revert. Things
should be in order now.
The declaration of some internal EO APIs was located in the wrong
library, which results on Windows to an invalid definition of
EAPI (dllexport vs dllimport).
Thanks @vtorri for the report!
This includes 4 events:
- render,flush,pre
- render,flush,post
- axis,update
- viewport,resize
Those were not accessible from the EO API since Evas.Canvas
isn't part of the public EO API.
This removes Evas.Modifier_Mask from EO.
This introduces two new types instead:
- Efl.Input.Modifier
- Efl.Input.Lock
Those are enums, not strings, containing all the known and
currently supported lock and modifier keys. The enums are
bit masks.
This effectively removes the ability for an application to
create and handle specific modifier or lock keys - with EO
API (legacy compatibility is unchanged, of course). I wonder
who ever required this?
Such an ugly API. This is an API to match a string to a number,
build a bitmask from it, and then use that. The supported
strings are well known (should be enum) and would need a
recompilation (ABI update) to support anything new anyway.
This may be a bit more controversial...
But Evas_Coord really is just an int and all the internals
of EFL assume that the base coordinate type is a 32-bit int.
So this type is a bit redondant and can't easily be changed
to, say, a float or int64.
Ref T5312
We only need it in elm_config.
This removes the type Evas_Font_Hinting_Flags from EO,
as well as the functions font_hinting_set/get and
font_hinting_can_hint.
Ref T5312
Note: it seems the EAPI evas_touch_point_list_xy_get() was
lst at some point, as it doesn't appear in the headers anymore.
It looks like we fail to catch an ABI break! abi_checker didn't
catch this!?
Ref T5312
Summary:
Removes extraneous newline, and fixes the indentation of the while
statement's sub-clause (which looked like a code error at first
glance).
Signed-off-by: Bryce Harrington <bryce@osg.samsung.com>
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4875
Summary:
_layout_ellipsis_item_new() function deallocates "ellip_ti" and
allocates memory for new one. The local "ellip_ti" pointer should be
updated.
@fix
Test Plan: N/A
Reviewers: raster, cedric, herdsman, jpeg, woohyun
Differential Revision: https://phab.enlightenment.org/D4854
I've done this by translating "Flip Page" to this new set of
EO APIs. In particular, absolute coordinates need to be used
in some calls, and the map needs to be calculated between
get and set operations.
This required an adjustment of the raw_coord API as the flip_page
code does some math after reading and then writing to the map.
Same for color. Those two properties now act like commands (ie.
like the other gfx map functions).
This also introduces a duplicate set of APIs to handle absolute
coordinates. Other solutions included:
- Use an enum to specify the type of coordinates (but then the
unit of cx,cy varies between non-unit relative position and
pixel position. Also this adds an extra argument to all those
function calls.
- Pass a special value (an empty eo object) as the argument for
pivot. Same remark about the unit as above. This way was
deemed too confusing because of the weird object.
Those two options have been discarded after asking the opinion
of a few developers I could reach.
@feature
This implements an entirely new API model for Evas Map by relying
on high-level transformations on the object rather than an external
Evas_Map structure that needs to be constantly updated manually.
The implementation relies on Evas_Map.
To rotate an object all you need to do now is
efl_gfx_map_rotate(obj, 45.0, NULL, 0.5, 0.5);
Or with a C++ syntax:
obj.rotate(45.0, NULL, 0.5, 0.5);
Or even simply (with default arguments):
obj.rotate(45.0);
The map transformation functions are:
- rotate
- rotate_3d
- rotate_quat
- zoom
- translate (new!)
- perspective_3d
- lightning_3d
@feature
Manual points population will eventually be useless as the
map API will become more like a transformation API, where
the current object geometry doesn't matter as much as which
transformation is applied to it.
With the wayland backend, it is posible to have no seat connected
until later. This would lead to calling evas_object_pointer_mode_set
and fail without returning a boolean it was impossible to detect it
did fail. This patch correct it.
Summary:
when collecting the objects under a mouse pointer,
evas uses the geometry of an object to decide
whether the mouse pointer is inside the area of the object,
which is inappropriate for a mapped object.
so mapped objects don't receive mouse events when they should.
this patch fixes the issue.
Test Plan: A sample code will be added as comments
Reviewers: jpeg, raster
Subscribers: cedric, eunue
Differential Revision: https://phab.enlightenment.org/D4826
Test case:
elementary_test -to "Gesture Layer"
Just move the pictures around (eg. to the bottom). They could
disappear entirely.
This is because the geometry used was based on the smart
object "bounding box" rather than the mapped output.
@fix
This is the first step toward handling multi output. This patch
remove engine.data.output from Evas structure and use an Eina_List
for it instead. It also start moving code around to fetch an output
or an engine context (which are the same at the moment, but will be
split in a later patch).
In a few classes, this requires some manual expansion. This should
not break anything but it's also fairly ugly; a better solution
would be appreciated, for now we do this.
Similar changes will be done to a few other Efl.Object APIs as
well at later point.
Summary:
When table items are left aligned and mirrored is set, items should be placed
from the right side, but align is not changed. (still left-aligned)
@fix
Test Plan: make and run attached example
Reviewers: cedric, jpeg
Subscribers: thiepha, woohyun
Differential Revision: https://phab.enlightenment.org/D4758
Honestly I can't see why gfx & gfx.path "changed" need a manual
definition, instead of relying on EO. If the API needs to be
internal only, then EO needs to handle internal APIs. In this
case, the event was exposed as a C API but not a EO... why?