This is an attempt at refactoring the filters code so I can
later implement GL support. This patch adds a few extra changes
to remove avoid calling functions of libevas from the software
engine: use the draw functions from static_libs/draw rather
than evas_common APIs.
The only purpose of this commit was to allow efl 1.19 to be
released on macOS wothout crashing on termination. Time to revert
it and see that we can find a real fix for the next release.
This reverts commit cd5e755951.
ref T5245
Test Plan:
- There are other grammatical errors, but I'm focusing this patch just
on pluralization-related issues to ease review and make it clearer if
I've introduced any inaccuracies.
Reviewers: cedric
Reviewed By: cedric
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4784
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
See the previous commit. efl_provider_find() could not
find a canvas because the event object had no parent.
This restores the slider in E's sound mixer.
Note: Input events may expose the evas canvas object
because of parenting. This will eventually need fixing,
as only efl.ui.win should be exposed.
If 8ff2dffe7c7a21278dis backported to 1.19 then this patch
also needs to be merged as well.
Test scenario:
elementary_test -to "ExtScroller"
Try and modify a slider's value with the mouse wheel. Bad things
were happenning, as the flag ON_HOLD was not properly propagated
from the slider to the scroller. This is because the legacy
event_info structure inside the eo event info was not updated
with the new flag value.
By introducing a new EO only API, which is meant to remain
internal, we can use a single legacy info structure, fixing
this issue.
Note: In the future this API needs to be internal, not protected.
@fix
Summary:
There's problem in Tizen3.0.
1. Clip set mask_obj to obj for masking.
2. Unset mask_obj from obj, and del mask_obj.
3. obj has clip.mask still. So obj is trying to do mask_subrender() for freeed mask_obj.
So reset clip.mask to NULL, If there isn't clipper.
Now, there's no routine for reseting clip.mask when clipper object is freed. isn't it?
Actually I'm not sure that clip.mask=NULL should be there as this patch.
Test Plan: Tizen3.0 wearable
Reviewers: cedric, raster, wonsik, jpeg
Subscribers: scholb.kim, dkdk
Differential Revision: https://phab.enlightenment.org/D4721
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
Since 9b7ac51943 evas map tries to avoid recalculating
stuff when the map parameters have not changed. Unfortunately the
code in elementary_test -to "Flip Page" was badly written. It was
modifying a constant's internal value (after ugly cast). So the
memcmp() and all other checks would return successfully, as the
exact same pointer was being compared to itself.
So, I've fixed the comparison by adding some forgotten parameters
(perspective) but most importantly I fixed the map API usage in the
test case.
There are reports of crashes when y < 0. This case seems
abnormal in case of filters, as I don't know how to reproduce it,
but it's happened.
Thanks Youngbok Shin for the report.
@fix
Summary:
If the last item before ellipsis item has bigger width than its advance,
evas_common_font_query_last_up_to_pos() function can find wrong ellipsis position.
When Evas finds a position for non last item, Evas must care about additionally
available space for glyph's width of the given x position.
ex) the last item's glyph before ellipsis item has a tail to draw above the ellipsis item.
@fix
Test Plan:
Test case will added as comment.
(Becasue of font license problem.)
Reviewers: herdsman, raster, jpeg, woohyun
Subscribers: cedric, Blackmole
Differential Revision: https://phab.enlightenment.org/D4727
just match the ref with the drop anddon't also manually free the image
as this leads to accessing of freed memory which is not a good thing.
this should fix T5374
@fix
old_clipper = evas_object_clip_get(objA);
evas_object_clip_unset(obj_A);
evas_object_clip_set(obj_A, new_clipper);
evas_object_del(old_clipper);
when old_clipper deleted, _clipper_del_cb unset the current new_clipper of obj_A.
Summary:
valign tag is for handling vertical align according to line's height and
text's height. But, it worked in a line which has only one font and
one font size, too. And the result was abnormal depending its font.
The line's height is [ascent + descent]. But, Textblock uses max ascent and
items's height(could be used max ascent + max descent according to its position)
when Textblock calculates item's yoff.
So, If Textblock calculate yoff based on line's height,
it should use only ascent and descent instead of max ascent and max descent.
@fix
Test Plan: Will attached in comment section.
Reviewers: raster, herdsman, jpeg, woohyun
Reviewed By: raster
Subscribers: cedric
Differential Revision: https://phab.enlightenment.org/D4760
Currently, elementary programs crash on termination on macOS (seems
Sierra-specific). This is very nasty, looks like deep memory corruption...
Without valgrind (or like) support on Sierra, it is difficult to
pinpoint the origin of the problem.
Due to the imminient release, and after discussion with @stefan, this
kludge will allow the release to happen.
This commit MUST be reverted just after the release, so we don't
blindfold ourselves!
Ref T5245
Summary:
The function already has a precondition test for !font, so this
additional test will never trigger.
@fix CID1371525
Reviewers: cedric, jpeg
Subscribers: jpeg, cedric
Differential Revision: https://phab.enlightenment.org/D4682
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
Since ecore now uses efl events to feed input events to the
canvas, anyone can now listen to any event on the evas. But
when using the legacy API the event info needs to be the legacy
struct, and not the eo event info otherwise crashes will happen.
While this is a new use of events, I consider it valid and it's
better to fix it rather than disallowing it. Fixed by wrapping
evas events the same way evas object events were handled.
Fixes T5266
Summary:
Earlier places in the function are testing if obj->layer is null, so
should be checked here as well before it's used.
@fix CID1371826
Reviewers: jpeg
Reviewed By: jpeg
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4707
this definitely fixes T5223 because it adds an engine lock around the
code segemtnt that does compare time stamps... and hopefulyl a few
more things too.
@fix
If GL context is free'd before processing font shutdown,
textures for emoji glyph's GL images will be free'd without clean
up its GL images. It causes eina mempool infinite loop issue when
emoji's GL images are free'd in shutdown process.
So, the patch will make a list for emoji's GL images in context and
clean up them when the context is free'd. Just like font textures in
context.
@fix
Differential Revision: https://phab.enlightenment.org/D4695
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
This will abort E when using Bryce and EINA_LOG_ABORT is enabled
(it is enabled by default when running a non-release version of E).
That's on purpose, as that code needs fixing :)
Ref T3144
When using smart objects (quite likely, isn't it?), the internal
layer usage count was not perfectly tracked. This was especially
true if layer_set() was called on a (top-level) smart object.
As a consequence, there could be no objects in the layer but the
usage would still be > 0. Thus, the layer was not deleted, not
removed from the inlist of layers, and efl_gfx_stack_above_get()
could return NULL as the layer above a certain object was empty.
Fixes T5201
The mouse cursor in a text entry tends to not disappear even when
the mouse moves out of the entry. This seems to happen more when
the cursor was visible for a single frame only (although I'm not
100% sure about this condition).
One important difference with previous versions of EFL is that
the cursor is now part of the theme, so it is an image object
and not set by the compositor (it looks vastly different).
Anyway, when processing the list of pending_objects, we look at
the flags render_pre and rect_del which were (re)set during the
previous frame. Those flags are then (re)set during phase 1 which
happens after processing the pending objects list... only if
needed. So, phase 1 sets the condition to invalidate the current
lists of objects but that condition is checked for before phase 1.
This patch adds a check on delete_me which should hopefully make
it a rare enough case, for performance, but still force correct
rendering.
This is all spaghetti code, sorry if this explanation also reads
like pasta.
Note that exactness tests may still be broken because earlier
versions of EFL simply did not have the cursor inside the canvas
itself.
Fixes T5231
I believe that all the threads created in our test suite should
be spawned without any special CPU affinity. The default parameter
is not 0 (corresponds to the first CPU, known as CPU 0) but -1.
Similarily the default priority is NORMAL (1), not 0 (URGENT).
This also affects two unused code paths: evas render2 and gl preload.
@fix
Summary: This new kind of APIs should be EO only.
Reviewers: jpeg, cedric, barbieri, bdilly, stefan_schmidt
Reviewed By: cedric, barbieri
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4696
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
If object's parent has map and object also has map, the evas
clip would be applied twice.
The context already applied clip area when drawing on map_surface.
So don't need more clipping when drawing map_image.
Also, make sure to apply the framespace clip when drawing the map
surface onto the final canvas. Thanks @jiin.moon for the initial
patch (see D4694).
@fix
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
Summary:
SETUP_LINE_SHALLOW and SETUP_LINE_STEEP are each identically defined
(except whitespace) in evas_line_main.c
Reviewers: cedric, jpeg
Subscribers: jpeg, cedric
Differential Revision: https://phab.enlightenment.org/D4681
Some property set calls to Evas Text are NOPs if the property was
already set to the same value. Avoid doing any work then.
This adds a missing intercept call (size_set as it's overriden
by Evas.Text).
This fixes a minor memory leak during shutdown.
Note: This does NOT perform the dlclose (and still leaks the
Eina_Module descriptor). Calling dlclose leads to a whole lot
of other issues, so we avoid it.
clip_dirty is called A LOT. Unfortunately this patch does not
result in very measurable improvements.
**********************
Note about this merge:
After this series of patches, the CPU usage for a certain test
case has significantly gone down:
Based on c0e6a8d698c17fc16f9b67fc9 (upstream before git push):
NS since frame 2 = 28910806786 , 2937 frames = 9843652 / frame
After this patch:
NS since frame 2 = 19218592951 , 2928 frames = 6563727 / frame
1.18:
NS since 2 = 13105584220 , 2961 frames = 4426066 / frame
As we can see, 1.18 remains *much* better than 1.19. I'm still
struggling trying to figure out why (clip_recalc is called more,
but the call tree is hard to decypher).
The test case is:
EINA_FREEQ_BYPASS=1 ELM_TEST_AUTOBOUNCE=100 \
elementary_test -to "Scroller 2"
EFL was compiled with GCC 6.3.1 with -O3 -g
@optimization
This function was moved out of inline (see d7c6fca6c0) but
unfortunately the early checks at its beginning are likely
to result in an early return. Inline this part so we get back a
better performance. Inlining the whole function does not improve
the performance, as GCC simply gives up with inlining.
Note: Between 1.18 and master the number of calls to clip_recalc
has simply blown out. It is thus crucial to find out where those
calls come from but also micro-optimize the function itself. This
patch does the latter only.
@optimize
No need to verify that the clip is an evas object unless we're
actually going to change said clipper. This has a minor effect,
removing ~10% of all calls to efl_isa (0.1% of everything).
After all those efl_isa patches the number of calls has dropped
from 1.9M (~3.05%) to ~570k (0.76%). More can still be done,
surely. Now efl_isa accounts for ~0.05% of my CPU usage according
to perf top (down from ~0.7%).
If edje uses EO APIs instead of legacy image APIs, then many of
the remaining calls will vanish.
@optimization
In relative smart move, we only need to check once that the object
is indeed a valid smart object. This drops the call count from ~1.02M
to ~785k.
@optimization
This avoids calling efl_isa and locking the async mutex.
In callgrind analysis, this reduces the count of calls to
efl_isa from 1.96M to 1.02M.
@optimization
Summary: this should fix some spamming in e
Reviewers: jpeg
Reviewed By: jpeg
Subscribers: cedric
Differential Revision: https://phab.enlightenment.org/D4675
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
The previous patch (b184874fa5) was preventing
post-event callbacks from triggering any form of input event,
including side-effects due to mouse,in. In fact by tracking
which exact events we want to post-process we can support
proper recursion. This fixes crashes in Bryce.
I'm not changing the documentation as this is still a dubious
code design.
Fixes T3144
Fixes T5157
See T3144 that I marked as Wontfix.
Bryce in E manually feeds events from a post-event callback
resulting in Evas going insane and leading to frequent crashes.
The ideal solution (for E) would be to ensure that everything works
smoothly, the input event data is valid up until the post-event cb
is called, etc... Unfortunately, with recursive events the exact
order of operations may be messed up: the post-event
I don't want to add yet more complexity to Evas events here (it's
already spaghetti all over the place) so I'm simply blocking any
new event feed when running the post-event callback list.
It's not possible to just freeze the events (I tried, it failed).
**********************
Some more explanation:
post-event callbacks are used to implement reverse-order logic
where the on-hold flag of an input event may be set by an event
listener that does not come first.
Here's a situation to illustrate: scroller A inside scroller B.
As events are propagated from children to parents (assuming the
propagate flag is set), we'd assume the events to go first to A
and then to B, which means a mouse wheel event would make the
inner-most scroller (A) scroll, and the outer-most scroller (B)
wouldn't budge.
But as things are designed, A and B are not simple evas objects,
and the actual event-catching object is a top-most transparent
rectangle (top-most in Z stack order). Since A is inside B, B's
rectangle BR is over A's rectangle AR, thus catches the wheel
event first. But in terms of UX we still want A to scroll, not B.
The solution then is to reverse the event processing order and
post-event callbacks are the way to do that. This comes with the
consequence that the event_info needs to remain valid until the
post-event is called, and stay the same (so that the on-hold flag
set by A can be read by B).
Recursive events (by explicit feed or modifying the canvas so
that mouse,in or mouse,out are triggered) mess with this logic,
and trigger the post-events too early (event is not fully
processed) or too late (event_info is not valid anymore... and
crash!).
Thanks @raster for explaining the goal of post-event callbacks!
This reverts commit b8beb6834b.
this now actually works... for some mysterious reason... ? :/ i am
baffled. go back in until we can find the issue then...
After a long search I found that fileselector was not calling
super.group_del on deletion, leading to the use of dangling pointers.
So let's verify that group_del is properly called.
See T4598
In this case data_scope_get is more appropriate as the data is
indeed stored on the stack (function scope) and not somewhere else.
After this last fix I see no eo_debug error logs in elementary test.
Yay! eo_debug is now usable :)
The data class should be specified for debug purposes.
Also, this fixes invalid uses inside the smart object
implementation where it assumed that the smart data was part
of the eo data. It may not (legacy objects).
This reverts commit c39855a8ac.
This actually breaks 1 dialog in e (app exited with error exit code).
it worked everywhere else so i thought it was good. seemingly not
after i saw one of these. revert D3595
Summary:
When a size calculation is skipped because of some reasons,
Evas Textblock should keep same size with the previous size.
@fix
Test Plan: N/A
Reviewers: raster, herdsman, cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4659
A use of the post event callback in Bryce triggered a double free
as an event was being processed but not yet removed from its list,
leading to an invalid state of the Eina_List.
Also remove obj from struct as it is unused.
Fixes T5157
if its a file downloading (to a tmp location) or a zip/tar/whatever
file being extracted also to a tmp location and that tmp file needs to
be removed after ...you need to keep the obj around to know when to
delete the file. this makes the keeping optional and you query if the
vpath obj is meant to be kept or not. if it's not it's safe to del
immediately.
this cuts down 1 obj per image obj/edje obj when generally unused.
save some mem.
otherwise we would just reuse that struct. This results in
freeing/writing/reading the memory twice.
This error message should give the dev a tip on what went wrong, instead
of leaving cryptic valgrind messages and crashes.
This fixes the sysinfo desktop gadget in enlightenment.
ref T5173
when the position of the container is changed the children should also be
repositioned, so setting the changed flag.
The visual effect where you saw that was in luncher where items of the
bar did not get fully up.
it's a warning one way or another so reduce noise with a harmless case
as passing in a pit ro a 32bit type is more restrictive than the ptr
it accepts (an 8bit type)
if balue is NULL the data binding is removed and freed, but we don't
return at that point but instead fall back to using/replacing the
databinding.
this fixes CID 1369022
several calls, specifically evas_object_change_reset,
evas_object_cur_prev, and evas_object_clip_changes_clean that are
called directly or indirectly as part of evas render on at least every
active object if not more, were doing full eo obj lookups when their
calling functions already all had the eo protected data looked up.
tha's silly and just adds overhead we don't need. my test dropped
_eo_obj_pointer_get overhead in perf profiles from 4.48% to 2.65%. see:
4.48% libeo.so.1.18.99 [.] _eo_obj_pointer_get
4.23% libevas.so.1.18.99 [.] evas_render_updates_internal
2.61% libevas.so.1.18.99 [.] evas_render_updates_internal_loop
1.68% libeo.so.1.18.99 [.] efl_data_scope_get
1.57% libc-2.24.so [.] _int_malloc
1.42% libevas.so.1.18.99 [.] evas_object_smart_changed_get
1.09% libevas.so.1.18.99 [.] evas_object_clip_recalc.part.37
1.08% libpthread-2.24.so [.] pthread_getspecific
1.05% libevas.so.1.18.99 [.] efl_canvas_object_class_get
1.01% libevas.so.1.18.99 [.] evas_object_cur_prev
0.99% libeo.so.1.18.99 [.] _efl_object_event_callback_legacy_call
0.87% libevas.so.1.18.99 [.] _evas_render_phase1_object_ctx_render_cache_append
0.82% libpthread-2.24.so [.] pthread_mutex_lock
0.81% libevas.so.1.18.99 [.] _evas_render_phase1_object_process
0.79% libc-2.24.so [.] _int_free
vs now the improved:
4.82% libevas.so.1.18.99 [.] evas_render_updates_internal
3.44% libevas.so.1.18.99 [.] evas_render_updates_internal_loop
2.65% libeo.so.1.18.99 [.] _eo_obj_pointer_get
2.22% libc-2.24.so [.] _int_malloc
1.46% libevas.so.1.18.99 [.] evas_object_smart_changed_get
1.04% libeo.so.1.18.99 [.] _efl_object_event_callback_legacy_call
1.03% libevas.so.1.18.99 [.] _evas_render_phase1_object_ctx_render_cache_append
0.97% libeina.so.1.18.99 [.] eina_chained_mempool_malloc
0.93% libevas.so.1.18.99 [.] evas_object_clip_recalc.part.37
0.92% libpthread-2.24.so [.] pthread_mutex_lock
0.91% libevas.so.1.18.99 [.] _evas_render_phase1_object_process
0.84% libc-2.24.so [.] _int_free
0.84% libevas.so.1.18.99 [.] evas_object_cur_prev
0.83% libeina.so.1.18.99 [.] eina_chained_mempool_free
0.80% libeo.so.1.18.99 [.] efl_data_scope_get
of course other things "increase their percentage" as oe overhead now
dropped, and things seem to move around a bit, but it does make sense
to do this with no downsides i can see as we already are accessing the
protected data ptr in the parent func.
so a little perf fun shows malloc/free/realloc/etc. are, combined a
reasonable overhead. this reduced malloc overhead for draw contexts so
whne we duplicate them or create new ones, we re-use a small cache of
8 of them to avoid re-allocation. just take the first one from the
list as it really is that simple. mempool would not have helped more
here and cost more overhead.
@optimize
cache flish and async end ended up dropping some cacneled images that
were then accessed further in the cancel func for the thread. this
fixes that
@fix
Coverity reports a resource leak here if we successfully load the evas
module as we were never freeing the eina_module here. Previously we
would just return the evas module without proper cleanup of the
eina_module. This patch fixes the leak by calling eina_module_free if
we successfully load the evas module.
Fixes CID1367503
@fix
Signed-off-by: Chris Michael <cp.michael@samsung.com>
so proxies just rendered nothing when used in terminology. they used
to work for the tab switcher (ctl+shift+home). this now works again.
there is a good chance this may break something else though... what i
can't seem to find...
this fixes T5131
Summary:
The static flag in evas_font_init() was not useful.
It could be replaced by checking address of "fc_config".
FcInitReinitialize() function was not necessary to reload
configure and font files in Evas. It would be meaningful
when only Evas use Fontconfig's function without own "fc_config".
To reload "fc_config", calling FcInitLoadConfigAndFonts() is enough.
And there is no need to load "fc_config" from evas_font_reinit()
when "fc_config" is not prepared.
Test Plan: N/A
Reviewers: herdsman, raster, tasn, cedric, woohyun
Subscribers: jpeg
Differential Revision: https://phab.enlightenment.org/D4612
During a stress test of EFL a seemingly impossible crash happened, where
one of object's cow fields was NULL inside evas_object_was_visible.
Nothing in the code flow can possibly lead to this situation but
it still happened. For information, the object's delete_me flag was 2 in
evas_object_is_active() called from _evas_render_phase1_object_process().
So let's add a small safety check for crash prevention.
Differential Revision: https://phab.enlightenment.org/D4608
Now the size evaluation will query for the native size of the
canvas.text object, and continue with calculations to set the min size
of itself.
This fixes a bug in containers where the widget's size wasn't picked up.
Also, the canvas.text object wasn't reporting 'changed' on text changes.
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
Textblock filters support RGBA input which means legacy styles
can be used in conjunction with filtering. Not recommended, but
it works. Note: We may decide to drop this behaviour and use
alpha-only inputs for simplicity.
Still missing: support for filtering strikethrough, underline, or
embedded items
Filters can have sources like image proxy, and should trigger
a redraw in case the source has changed. Since we cache the
filter's output, we need to first check whether the sources
have changed before reusing a previous output buffer.
If the line height is different from the text item height (eg.
because there are large embedded items) then we need to add
an extra offset to the draw commands.
Note: items themselves are not filtered (yet, at least).
This is a first step before implementing some form of caching of
those output buffers. At the moment, it very aggressively deletes
any buffer that falls outside the clip of the textblock object.
Note that this is better in terms of memory usage but way worse
in terms of render performance (eg. scrolling). If a textblock
is a proxy source then we keep all the buffers (the entire object
is to be rendered).
+ fix a crash
This will be triggered in the rare case when a textblock's
insets are changed (ie. the padding due to filters or style).
This fixes invalid sizing in the test case in elm (due to a
lack of event after program_set).
@feature
This is the most basic optimization that needs to be done for
filters to be useful: cache the output rgba buffers for each
filtered element. Hopefully this doesn't leak. I'm not making
any promises about that though :)
This is a function that allows passing variables from C or EDC
to the filter's Lua code. Useful in particular for color classes
from EDC.
This data would be the global data but we could eventually add
a markup tag to specify a data value per filter instance. For now
a single data value per tb object should be more than enough though.
This makes gfx filters padding work just like the standard style
padding, which means the tb user must offset the object position
by -l, -t and increase the object size by l+r,t+b.
If a gfx filter was applied to a block of text spanning over
multiple text items, then it would improperly render as the
filter context was stored in the format, rather than the text
item. This is fixed by using a list of contexts in the format
node rather than a single context.
This is only for testing purposes for now. Eventually we need
to fix the following things:
- terrible performance (cache buffers)
- force redraws based on filter padding
- expand textblock padding based on max filter padding
- add sources, data and a filter name/code hash
- test! :)
This should save a bit of memory for all image & text
objects. This exploits the previous patch for the post-render
job queue added to evas, and simplifies this bit of code.
This is a preparation step for (experimental) textblock support.
Textblock objects won't have a single filter, and the buffer's
geometry wouldn't be that of of the object itself. Thus a few
internal APIs need to be reworked first.
so if you queue a preload while a cancel is still pending the new
preload never happens. this fixes that. now it does but checking for
leftover tasks in the cancel cb and rescheduling a preload thread.
@fix
In gl engine, image objects try to unload image's pixel data after creating or updating the texture.
but image entry's reference is still 1, it is added to the pending_unloads list,
and it is cleaned when evas render function.
If elm image use preload feature, preload_done flag is true, so this image data cannot be removed from
pending_unloads list, it cause memory leak.
I think it is better to free image's pixel data in evas_cache_image_unload_data,
(not add to the pending_unloads list)
but it it complicated to modify.
so I'll remove the code to check preload_done flag in evas_common_rgba_pending_unloads_cleanup function.
this flag check was added because of gl preloading, but now gl preloading feature is disabled.
this flag is related with https://phab.enlightenment.org/D2823
I tested photocam, but crash doesn't occur anymore, even though removing flag check.
Object size hints are stored in a specially allocated struct
(from a mempool) and even a call to size_hint_set(default_values)
will allocate this struct. This patch avoids unnecessary allocations.
Originally I was trying to fix an infinite recalc loop but it
magically vanished...
Summary:
This property is not needed and it will only increase the API size.
One can simple achieve the same behaviour by simple doing:
//C code...
Eina_List *l;
Evas_Device *dev;
devices = evas_device_list(evas, NULL);
EINA_LIST_FOREACH(devices, l, dev)
{
Evas_Object *obj;
if (evas_device_class_get(dev) != EVAS_DEVICE_CLASS_SEAT)
continue;
obj = evas_canvas_seat_focus_get(dev);
//Do something with the focused object.....
}
//More C code...
Reviewers: bdilly, barbieri, conr2d, jpeg
Reviewed By: jpeg
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4547
Summary:
When using evas_object_image_data_set(obj, data), if you give the value of data to NULL, the image data is free.
However, Since you have not set a flag in the image object to be modified, it will not be processed in the next render loop.
Eventually, the image data is erased, but you see the image before it was erased.
If evas_object_image_data_update_add() is used to solve this problem, the operation of the function is skipped because the values of w and h in image are 0.
So, If data is NULL, I modified it to call evas_object_change() in evas_object_image_data_set().
Test Plan:
Sample code
{F61599}
{F61601}
Reviewers: Hermet, jiin.moon, eunue, jpeg
Reviewed By: jpeg
Subscribers: jpeg, cedric
Differential Revision: https://phab.enlightenment.org/D4520