Summary:
the api returns if a rectangle is positioned above/below/right or left
of a other rectangle.
Code which does simular things are part of verne and e, i think its a good idea to provide api for that.
Test Plan: Just run the test suite
Reviewers: raster, jpeg, cedric
Reviewed By: cedric
Differential Revision: https://phab.enlightenment.org/D4489
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
visit_unsafe member function visits the variant but assumes the
pre-condition that the variant is not empty. This avoids the
possibility of throwing an exception when the destructors
of the types used in variant are also guaranteed to be
noexcept.
CID 1367508
If someone's trying to build efl git with 2.5 year old EGL headers they get
a break on missing EGLImage...
We should probably consider keeping an up to date copy of the EGL headers
in efl. There may be someone out there with even older headers.
While a socket can be closed to receive data resulting in EOS, it
could still be used to send stuff. Then it won't result in "finished",
just "read,finished" event.
However, previously this was considered a disconnect and we must
respect this otherwise tests (Ecore_Con_Eet suite) will hang waiting
for a disconnect.
By marking EOS on the outgoing queue we allow the sender to flush
pending data if that's possible.
This also fixes a typo in the condition for eos_mark, it operates on
outgoing, not incoming queue.
Before we're exiting if there was nothing pending, but in some cases
this was too aggressive as the copier's source may be alive (ie:
not-EOS), however nothing was read to its internal buffer, thus no
pending.
Since the copier will track its source's EOS, just check if it's done.
On destructor we're not supposed to emit events, I even thought that
would be implicit, but it's not. If we do, for example an event
handler that would 'efl_del()' on "EFL_IO_CLOSER_EVENT_CLOSED" would
trigger too-many unrefs.
Copier is based on Efl.Io.Reader.can_read,changed and
Efl.Io.Writer.can_write,changed, these events do not keep being posted
until it's actually read/written, instead they trigger only once when
the property change -- unlike Efl.Loop_Fd read/write events.
Some code needs to read directly into eina_binbuf to avoid an extra
copy from eina_binbuf_append* variants.
This can be achieved by using eina_binbuf_expand(), which returns a
write-able slice of the spare bytes. Once they are used,
eina_binbuf_use() should be called to increment "buf->len", which is
used by all other binbuf functions such as eina_binbuf_length_get() or
eina_binbuf_append_slice().
This reverts commit 4e110a34bf.
Urgh. I'm stupid. Conceptually I still like the idea of the
region proxy, that only renders part of the source object
in a proxy surface. The problem right now is that the proxy
subrender mechanism renders to a surface that belongs to
the **source** and not the proxy object. As a consequence,
the region would become a property of the source, rather than
the proxy, which is not at all the intention of the original
patch. In other words, everything would fall apart if an object
has more than one proxy, for whatever reason.
I realized that when trying to actually test the region proxy.
It didn't work at all. Revert for now.
Summary:
In case if WM_SYSKEYDOWN or WM_SYSKEYUP events are handled in
DefWindowProc - system doesn't init event for a system shortcuts.
For example any EFL application on Windows couldn't be closed by
Alt+F4 combination.
@fix
Test Plan:
Launch Elemenatry_test app.
Try to close by Alt+F4 combination.
Reviewers: vtorri, raster
Reviewed By: raster
Subscribers: an.kroitor, bowonryu, cedric, jpeg, #eflete
Differential Revision: https://phab.enlightenment.org/D4477
As suggested by @k-s
I'm pretty sure that this parser will easily fail. Eg. find uchar
properties but it's not r,g,b in this exact order? No color for you.
Find no uchar at all? Fail immediately even if we can handle a
no color situation just fine.
UDP client has no socket on its own, so it can't be marked as
close-on-exec, however failing to resolve the method is bad as
confuses the user.
Instead provide a method that checks if the setting is different from
parent, in such case provide a meaningful message. Otherwise just be
quiet.
remove one more TODO: since Efl.Net.Ip.Address was introduced we can
now expose Efl.Net.Socket.Udp.init as a protected method that will
configure the internal address we use for the remote peer. This allow
subclasses to override or call such methods.
There are no jobs to stop there, it was a left over since this code
was somehow derived from Efl.Loop_Fd where "read" and "write" would
constantly be called until the kernel flag was cleared, there the
callback must be removed to stop jobs, not here.
Only the size of events_whitelist isn't enough, because in some
cases the user may be disabling the usage of a specific seat.
Considering the following scenario, the issue will easy to understand:
- an application with two entries (one to be used by seat 1 and other
by seat 2)
- the first seat is announced - it is enabled for entry 1 and
disabled for entry 2
- the second seat is announced
Before second seat is announced, the first seat would be able
to input the entry 1, because the events_whitelist of such
object will continue empty.
So a flag will be used to identify an object with active
filter.
Reviewed By: iscaro
Differential Revision: https://phab.enlightenment.org/D4498
It doesn't make sense to remove it when a seat is added
to the list. It should be removed only when this seat
is blocked.
But when the list receives its first item, then
it also should be checked if the focused seat
is the one just added, otherwise the previous one
must be removed.
Working directly with Eina_Slice is easier than a pointer to it,
requires no validation of the pointers and is cheap since it's just
putting together size_t + void*.
However we can't hint the user of 'const(Eina.Slice)' properties as
Eolian is incorrectly generating getters as:
const Eina_Slice class_property_get(...)
which is makes compilers complain about ignored qualifiers:
../src/lib/ecore/efl_io_copier.eo.h:329:7: warning: 'const' type qualifier on return type has no effect [-Wignored-qualifiers]
Leave some TODO so @q66 can fix those.
Previously we couldn't return a slice, instead required the user to
pass a slice and we'd fill it since Eolian couldn't generate fallbacks
for structures.
Since @q66 fixed eolian, we can now return the structure itself as
initially wanted, ditching some TODO from the code.
Since seat names defined on evas will depend on evas backends,
maybe udev rules, etc, we aren't able to demonstrate it
without manually setting another name for such seats
with efl_input_devices_name_set(). Otherwise
we wouldn't have guarantees it would match
names on EDC.
collections.group.use_custom_seat_names should be set to '1'
to use seat names on signals as provided by Evas.
By default just follow Edje naming approach
("seat1", "seat2", ...)
If not provided, FOCUS_OBJECT action will keep acting
over default seat.
Also include a usage on edje-multiseat test
(actually no example was exercising this action).
Seat goes as an optional parameter for FOCUS_SET (if not
provided, act over default seat), and emit signals
with seat suffix:
* focus,in,$SEAT
* focus,out,$SEAT
* focus,part,in,$SEAT
* focus,part,out,$SEAT
Some applications will create the handle, immediately send data, flush
and delete it, expecting the data to be sent to remote peer.
This is a bad behavior as the application would become unresponsive
until the connection is established, data can be written (since
depends on server consuming it), then allow it to be closed.
A proper behavior here would be to chain based on events, with the
usage of a copier would be simply wait for "done" event.
However the legacy API allowed this and terminology depends on this
awkward "feature", thus be bug-compatible.
This fixes T5015.
In the old/legacy API the socket would be opened early in non-blocking
mode (connect returned errno==EINPROGRESS), with UNIX socket being
path-validated early and returning NULL as 'server' handle.
Some applications relied on this instead of monitoring the "ERROR"
events, considering the connection to be successful if there was a
handle -- this was the case with Terminology after it moved from DBus
to Ecore_Ipc.
Although this is not correct, we must keep compatibility and thus we
stat() in compatibility layer, failing early as the old API would do.
These legacy API had the nasty behavior of keeping handles alive until
the pending events were dispatched, this could happen after the module
itself was shutdown, resulting in log to unregistered domains.
Then do not unregister the domain -- eina_shutdown will avoid leaks
anyway.
Coverity reports that 'reply' is leaked here if we fall into the error
condition.
CID1367507
@fix
Signed-off-by: Chris Michael <cp.michael@samsung.com>
Summary:
When width of parameter(w) is bigger than or equal to scroller's width(pw),
scrollable object must be scrolled to x position.
Test Plan: elementary_test -> focus 4
Reviewers: woohyun, SanghyeonLee, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4491
Summary:
scrollable object.
In multiple scrollable case, the target object should be updated.
Because the first object is scrolled. So the parent of the first object should be scrolled.
Reviewers: woohyun, Hermet, jpeg, cedric, raster
Differential Revision: https://phab.enlightenment.org/D4490
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
Summary:
The way to find the position of hoversel expansion is based on geometry
currently, but it causes errors when theme is not made as expected.
This patch makes hoversel use string to find the right position and
calculate item width correctly when items are shorter than hoversel itself.
Test Plan:
elementary_test -to hoversel
(error case shows in tizen mobile device when screen is rotated)
Reviewers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4484
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
There's actually an array of 2 in gl_x11, but it appears we only use the
first 1, except in an #if 0 block.
I gather this is legacy for some reason - it sure doesn't seem to make
any sense now, so I'm chopping off all the extra array indexes.
Note: I've not changed gl_sdl - it looks like it doesn't use the context
or surface at all and they could just be removed, but I don't build that
one here and don't want to touch it.
This implements support for efl_text_set() for the default
part (NULL). This also adds support for efl_text_set(efl_part())
for layouts. This should cover a LOT of widgets :)
The next step is to remove Elm.Layout.text but it's used in too
many places at the moment. @herdsman!!
After a previous patch, mask_subrender worked differently, and
didn't reset the object's cache clip color. This made evas_suite
fail. But also it seems some other issues creeped in and it was
necessary to fix the test case by adding data_updates (mistake!)
and removing an invalid draw call.
teamwork api in elm win (efl_ui_win) has a few issues:
1. it directly ddigs into ecore_wl2 and uses internal headers to use
zwp_* api's directly... which effectively tied elementary directly to
libwayland and thats not a good thing - thats why ecore_wl2 exists -
to act as a layer in between
2. the only thing that supports it is e and only wiht a module and
there is no fallback code in elm to work outside this environment, so
it's kind of broken by design and will not actually reliably work
3. from a stability and security point of view, and api and protocol
that allow a client to ask your wm/compositor to open ANY url - go
make a network request possibly to a hostile url/site is bad. needing
to handle so so so so many protocols, file types etc. etc. is going to
lead to issues that SHOULD at least be isolated in the app, but now it
spreads into your wm/compositor too. :(
4. there is ZERO benefit to asking the wm to do this. the app is
using efl already. it already has all the same abilities with the same
libraries to download/display etc. so why doesnt the app do it itself?
5. doesnt work in windows, osx, framebuffer (fbcon or drm)... only in
x11 and wayland. (and then only with e + module)
6. there is no way to detect if it's going to work and write your own
fallback (which shouldnt be needed/done anyway).
nice work and enthusiasm on making teamwork but it just isn't the right
thing - not in its current form and not by design (security reasons) :(
@deprecate
ECORE_X_ATOM_E_ILLUME_SLIDING_WIN_STATE
ECORE_X_ATOM_E_ILLUME_SLIDING_WIN_GEOMETRY
ECORE_X_ATOM_E_KEYROUTER_SUPPORTED
ECORE_X_ATOM_E_KEYROUTER_WINDOW_KEYTABLE
all had no atom fetches! fix..
@fix
this adds the a stack of windows (view stack, something like naviframe
but using multiple windows instead) to elementary allowing windows to
be put into a stack and treated as one "application" when ijn such a
stack with the newest window on top being the active/focused one (or
should be). this allows for special show/hide animations as well as
possibly special sizing policies and placement policies.
@feature
This fixes a rare crash in the SW engine when a masked mask is
to be rerendered. The clip adds more safety as the lower render
draw functions assume it is properly set.
Here's the situation:
1. A container (genlist) has a mask, M0.
2. An item I0 inside this container uses a proxy P0 as render object
rather than the item directly (eg. for zooming in/out).
3. An element E0 inside this item has another mask, M1.
Theory:
1. The proxy surface for P0 is rendered, and M1 is applied to
the element E0.
2. The proxy P0 is rendered on the canvas, with M0 applied.
Practice:
1. The element E0 is prepared for rendering, this triggers
a mask subrender for M1.
2. M1 is rendered with M0 as a prev mask, then kept in cache and
not redrawn (no geometry change, etc...)
3. When P0's surface is rendered, M1's surface is the result of M1+M0.
4. When P0 is drawn on screen, we can see the effect of M1+M0 as
P0's geometry might be different from the item's I0.
Solution:
Discard prev masks and force a mask redraw when we're inside a
proxy. Ideally we should detect if the prev mask belongs to the
insides of the proxy or not.
Problems:
_mask_apply_inside_proxy() is definitely not correct, but it's
not easy to test it. Anyway I believe that in order to properly
implement all of this, we need to rethink evas_render and
the draw context. Non-primary render surfaces (maps, proxies,
masks, filters, ...) should be rendered with a clean context
and clipping, masking, etc should be computed appropriately.
Always assume use_mapped_ctx as true, the caller of evas_render_mapped
must ensure that the context is suitable (so either clean or contains
the appropriate clip info).
Also pass do_async to mask_subrender. For now it will always be reset
to false as the SW engine requires sync render to convert from RGBA
to Alpha (not great). The upcoming GL async engine should be able to
render masks asynchronously without any problem.
This can avoid some invalid render from evas_render_mapped in
a rare case. I'm not sure about the conditions but I know for
sure that at the moment mask_subrender should be only rendering
plain old images into a dedicated surface. So no need for
evas_render_mapped here.
It was never used, except in dubious situations (most likely a typo).
A clean context is now used in the top-most call to
evas_render_updates_internal_loop.
This makes code shorter and easier to read (imo).
Also introduce ENCTX for the engine context. It's used in a couple
places and I believe it's just wrong - but works because the engine
context and the current context are the same.
This will allow partially rendering a proxy in a smaller image,
limited to the specified region. At the moment, this will allow
apps to create proxies of very large objects and let them deal
with the geometry & clipping.
This is not directly solving the issues with adding a filter
to textblock or the infinite page scrollers.
@feature
Jee-Yong Um
Marcel Hollerbach
Cedric BAIL
Guilherme Iscaro
Felipe Magno de Almeida
Derek Foreman
Chris Michael
Carsten Haitzler
Gustavo Sverzut Barbieri
WooHyun Jung
Stefan Schmidt
Jean-Philippe Andre
Mykyta Biliavskyi
Bruno Dilly
Andy Williams
Ivan Furs
Hosang Kim
Vyacheslav Reutskiy