Summary:
part.clip_to statement has short handler named "part.clip"
while part.description.clip_to does not.
Its short handler name should be "part.description.clip"
in order to have same experience with "part.clip".
Reviewers: cedric, Hermet, jpeg, conr2d
Reviewed By: conr2d
Subscribers: conr2d
Differential Revision: https://phab.enlightenment.org/D4789
Summary:
Applications want to know the current keyboard mode state to handle application's size manually.
So added a new ecore_imf_context_keyboard_mode_get API and input_panel_event_callback type for
keyboard mode.
Test Plan: Tested in Tizen device
Reviewers: jihoon, woohyun, id213sin
Reviewed By: jihoon
Subscribers: cedric, jsuya, z-wony, jpeg
Differential Revision: https://phab.enlightenment.org/D4790
Elm_fileselector has the hardcoded value for calculate the item size
with thumbail, this size was 16, it's looks like thumbnail size plus
labal text height, but hardcoded value haven't effect to scale. Other
problem with items without labels. As a result we have correct
thumbnail size only with default theme and with scale 1.0.
This commit made the item size accordingly to size what user set. It's
made more clearly this API behavior.
@fix
By some reason style does not applyed to genlist/gengrid in
fileselector. Also fixed issue with applyed style for files view on
change mode. Now this problem is fixed.
@fix
After talking with @eunue I realised that the way I'd first
implemented the box/grid "pack" API was simply too complicated.
I had tried to make it possible to change the layout function
at runtime, like good old evas box, but since there are no function
pointers in EO the final design was really convoluted.
If someone really needs to change the layout of a box at runtime,
just create your own subclass, or unpack all items and repack them
in a new box.
Note: there are still some issues with the layout params & flow
If efl_object_override() is called with a function that does
not exist in the original class, it may lead to a crash on
indexing an non-existing array in the vtable.
This is really just a safety check, as the usage was wrong:
* You are only allowed to override functions that are defined in the
* class or any of its interfaces (that is, efl_isa returning true).
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?
Summary:
The values(259200, 86400) are hard to know the meaning.
And we don't have to call gmtime() in for loop.
Test Plan: elementary_test -> calendar
Reviewers: jpeg, Hermet, shilpasingh, cedric
Reviewed By: cedric
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4717
ecore_wl2 contains a bunch of code for compositor side seat handling.
There's really no need for a client to do this, and E does the
compositor side seat stuff internally, so this code will never
be used.
This removes the unused code.
Summary:
When the keyboard mode state is changed, the keyboard_mode_event_cb will be called, too.
But there is no way to get keyboard mode manually.
Test Plan: Tested in Tizen device
Reviewers: jihoon, woohyun, id213sin
Reviewed By: jihoon
Subscribers: jpeg, z-wony, jsuya, cedric
Differential Revision: https://phab.enlightenment.org/D4786
so our yuv import funcs for gstreamer 1.x engine were ignoring the
plane offsets and strides provided by gstreamer. though this nicely
shows that these numbers provided are actually wrong - at least in the
testing with vaapi back-ends with gst.
so this fixes emotions' badness but there is still badness in gst
apparently. the numbers provided if used are just simply wrong for teh
image data. commented code in the src to show how to "Fix it up" by
forcing some alignment of content to get it to work.
@fix
This might not be used as over two consecutive runs all the
same buffers should be used. But it could happen if some
parameters in the filter change (eg. blur radius).
Fixes major (GPU) memory leaks. Reuse mode is still leaking.
An odd-sized image scaled down by 2 was losing 1 pixel during the
downscale, and it was not restored after scaling up. The same
happened with downscaling by 4 except the effect was even more
visible.
This meant that a moving snapshot with a large blur would trigger
some really ugly sampling issues if the content below was precise
(such a text).
If the obscured area in a snapshot object changes a lot, do
not try to keep track of it forever. Instead, redraw the filter
over the entire object region, without obscure.
This fixes a performance issue when an opaque window is moved
above a fixed transparent window (the latter has a snapshot with
blur filter).
This dramatically improves the performance and now seems
to give acceptable results. Eventually we need a quality flag
in order to enable this or not. Alternatively, "gaussian" blur
mode would skip this optimization, while "default" would trigger
it.
When the filtered object is an image, without borders, map,
fill info or anything of this sort, then the filter input
buffer is really just a copy of the original image. We can
skip that to save on memory usage and pixel fetches.
This can help with performance when a large region of the
filtered image (eg. snapshot) is fully hidden by an opaque
object. For instance the window border is hidden by the
opaque window content.
This improves over the previous code for handling
snapshot objects and cutouts. Basically any opaque object
above a snapshot should be obscuring it. That is true
unless a crazy filter is applied, or the snapshot object
is itself the source of a map or proxy.
This also uses eina_tiler instead of a custom (and really
bad) algorithm to compute the obscure regions.
This make save() work on snapshot objects, provided the call
is done from inside render_post.
Also, this saves the filtered output of an image, rather than
its source pixels. Any call to save() on a filtered image must
be done from post-render as well.
Fixes T2102
@feature
If we delete the image that was the target surface for gl
rendering, a crash would occur on the next render cycle.
Unlikely but not impossible to trigger from app side.
@fix
This was a poor attempt at improving the performance but
obviously the root cause isn't fixed (too many texel fetches).
Uniform should (theoretically) work better than an attribute
the for loop. Just a guess here.
This also makes GL blur use a float value as radius, allowing
future extension to non-integer blur radii, as well as using
linear scaling as a fast blur approximation.
This factorizes some of the common code for image render
and resolving is_inside (verifying alpha value of a pixel).
This should also be used by save(), as well as buffer_map().
This patch introduces lots of whitespace changes by using return
instead of long if() {} or else {} blocks.
The situation is clearly visible in the Snapshot test case:
increase the radius and a red glow would appear. This is because
the snapshot object was not marked as needing redraw and so had
no pixels under the opaque rectangle.
This will reuse existing buffers by resetting only the minimum
required in the filter context (also reused). Work in progress,
as the actual reuse is disabled for now.
This avoids creating one more FBO and doing one more draw,
by rendering the image input data directly into the input
buffer. This also makes the code common between SW and GL.
This optimizes the GL blur algorithm by reducing the number of
texel fetches (roughly half the number of before this patch). This
works by exploiting GL's interpolation capabilities.
Jeeyong Um
Sungtaek Hong
Jihoon Kim
Vyacheslav Reutskiy
Jean-Philippe Andre
Carsten Haitzler
Woochan Lee
Derek Foreman
Jean Guyomarc'h
Ivan Furs