Ecore Evas: Add multi seat support for mouse in/out.

Evas: Change evas_canvas_seat_focus_get to property.

Ecore_Evas: Add support for per-seat focus.

Ecore Wl2 Input: Canvas focus IN/OUT events should contain the seat.

This provides the information about which seat originated the event.

Evas: Add per seat Evas focus state.

ecore-evas-drm: Implement ecore_evas_screen_dpi_get for drm canvas

Small patch to implement support for ecore_evas_screen_dpi get on the
drm canvas. This will be used in enlightenment (e_scale) to get the
screen dpi of the compositor canvas when we call e_scale_update.

Signed-off-by: Chris Michael <cp.michael@samsung.com>

ecore-drm2: Add API function to return screen dpi

This patch adds a new API function which will be called from
Ecore_Evas to return the screen dpi

@feature

Signed-off-by: Chris Michael <cp.michael@samsung.com>

example: update edje-edit-part-box to use not deprecated functions

since box/table item API is deprecated and replaced with new API, it is important
to use them in example as well

Fixes T4931

elementary-cxx: Fix filemvc wrong usage of Efl_Future

eeze_scanner: now using efl_net.

Rewrite eeze_scanner on top of efl_net_server_simple.

eeze_scanner: add monitor (client)

In order to test eeze_scanner it's handful to have a client to monitor
for broadcasted events.

efl_debug: fix typo, EXIT_FAILURE not EINA_TRUE.

although the same value, be clear on it.

docs: efl_input: add property doc for newly added item

elm_multibuttonentry: Using current w,h value for item size calc when box resized.

Summary:
Support in case that If the expand mode is set to false
and the item is added using the item_append API.

Checking focus, entry visible is not needed to change mode in shrink when box resized.

If the view type is shrink when the MBE is in focus and the box is resized, it should be in shrink mode.

Test Plan:
elementary_test
MBE sample

Reviewers: woohyun, Hermet

Subscribers: cedric, jpeg

Differential Revision: https://phab.enlightenment.org/D4429

win: Move main menu back to win.edc (fix sizing)

As Andy reported, the main menu geometry is not correct after
my recent changes, as the application contents slide underneath
the menu bar. In fact the menu bar is just floating above
everything else.

So I've tried to move the menu to the framespace (as it should
belong to the frame), but the sizing algos for both the window
and the menu make some assumptions that render this task quite
difficult. Eventually I would like to be able to swallow the
menu somewhere else inside the border... but not right now.

win: Remove unused variable

win: Avoid calling need_frame_adjust all the time

This function was meant to be called only before
finalize. This avoids getenv and string compares.

elm_code: Add some missing indent tests

tests: Update for elm_code indent changes

eo: safety in string comparison

Avoid potential for Eo to crash if app manages to unset key
@fix

elm_code: A better colour for comments

tooltip: Don't warn when clearing tooltip if none set

This behaviour was already agreed, I just didn't notice the warnings created

elm_code: Slightly smarter indent logic

Continue comment blocks where appropriate...
A bunch of refactoring of text/indent code to expand further

efl ui win - stop trying to get data of non-image icons

x11 updates trying to update x properties from image data when icon is
not an image is causing lots of error spam. fix this to check type
first before getting data.

ecore animator - timer based ticker - add epoll support if available

the ecore time based animator that ticked away used select for
timeouts to listen to either a timeout OR the control fd that would
tell it to tick or not tick. my profiles show this as consuming 1.03%
of my profile sample time - just  the select call in the time based
animator. this adds the option of epoll + timerfd + having kernel
repeat the timer fd interval (since epoll timeouts at best can do 1ms
resolution). my profiling shows this to use 0.62% of profile time vs
1.03% for select, so it's a tiny win. this only compiles if epoll and
timerfd support have already been detected at compile time. it also
runtime falls back to select if epoll and timerfd setup fail.

@optimize

evas render - don't do extra if checks or loops if not needed

remove some extra looping and if checkign that is taken care of
already and just is pointless extra checks in the code creating
overhead. tiny amounts, but the amount of meaty speedups lef it
running low, so profiling, reading, working and repeating.

@optimize

evas render - evas_object_clip_recalc - dont call uselessly

evas_object_clip_recalc was already called ... multiple times in
pending and phase1 on all objects, so there is no value in calling it
again and again in later evbas render phases when it's already been
done.

this and moving this to a real func sees evas_object_clip_recalc usage
in perf drop from 1.8% to 1.4% or so of total perf sample time. tiny
win, but we're at the point where i can't find big meaty wins, so i'm
looking for a string of small wins to add up.

@optimize

evas render and clip calc - move evas_object_clip_recalc out of inline

evas_object_clip_recalc is big. it's fat. it shouldnt be inline. so
make it a real function. being inline just hurts performance by making
our code bigger, hurting l1 instruction prefetch and cache
performance. this function isn't small. it's huge and should not be
inline basically because of that reason.

also throw in some likely/unlikely hints etc.

@optimize

evas_render - store active obj geom in array to be able to filter faster

part of rendering is figuring if obj is inside current geometry.
before we had to actuall poke around inside the object. this moves the
geometry into the active object array so the data is fecthed fast and
already there for filtering as this is the most likely thing to filter
out an object.

unfortunately this seems to have some bugsd and i'm baffled why, so
leave it there and ifdefed out for now for suture hunting.

evas render - remove unsed eo obj handle in pending object smart change

unused eo obj id, so dont have the line of code. - clean up code

evas render - remove another scope data get when we already have it

we already have the obj protected data so why scope data get it again?
fix and optiomize.

@optimize

evas render - get scope data less in phase 1 where obj data passed

in much of phase1 we already know the evas object protected data ptr,
so dont scope data get it or even pass the eo obj id around as we can
get it from obj->object

evas render - remove excess scope data get when we already have the ptr

_evas_render_is_relevant() needs the obj protected data, so it gets
scrop data, but the only place it is called already has this pointer,
so avoid an extra lookup.

@optimize

evas render - cache object arrays rto avoid processing them in phase1

evas render in phase1 in order to generate update rects, active,
render etc. object arrays has to walk every object in our tree. this
is a waste of time if we already have walked objects in a previous
frame if they havent changed, so cache this data in render cache in
smart objects to avoid re-walking and now just dumbly "memcpy" these
cached arrays into the master array. i have seen cpu usage by e drop
like about 15% in the sencarios i'm looking at "enlightenment
compositor with some window updating animation all the time, but most
other stuff being static).

@optimize

evas phase 1 process - shortcut objects that are pure static clips only

these objects don't actually produce - or should produce update
regions etc. etc. as the objects that are clipped should produce those.
they are not active objects. so skip them very early after just
ensuring they are in delete objects if needed.

eo base class - clean up some formatting around callback add/del code

just formatting changes really.

efl_debug (client and server): now on top of efl_net_{server,dialer}_simple.

Much simpler! :-D

efl_net_server_unix: add leading_directories_create property.

This allows us to crete any parent directories that are missing.

efl_debug: use new efl_net_dialer_simple, remove lots of code.

this is what led me to create the efl_net_dialer_simple, this kind of
code was being repeated in too many places.

efl_net_{socket,dialer,server}_simple: easy to use, buffered network sockets.

The low level I/O primitives are powerful but adds some complexity to
use, for bi-directional streaming communication one ends creating two
Efl.Io.Queue and two Efl.Io.Copier to pipe data to socket when it can
operate.

Then encapsulate the socket using the new Efl.Io.Buffered_Stream, this
will allow the socket, be a dialer or a server client, to be operated
as a single handle that internally carries about the buffering for
you.

As one can see in the examples, compared to their "manual"
alternatives they are very easy to use, ressembling
Ecore_Con_Server/Ecore_Con_Client, but also offers line-based
delimiters and the possibility to let the socket to handle queueing
for you in case you received partial messages (just do not
read/clear/discard the received data).

efl_io_buffered_stream: wraps an I/O object and make it easy to use.

Since all other efl.io objects are low-level, the recommended approach
is to use an efl.io.copier. However when dealing with in-memory,
bi-directional comms like talking to a socket, we always end with 2
queues, 2 copiers and the annoying setup that is being replicated in
ecore_ipc, efl_debug and so on.

This class is the base to make it simpler. Other classes such as
Efl.Net.Socket.Simple, Efl.Net.Dialer.Simple and Efl.Net.Server.Simple
will use it to provide simpler code to users.

I guess we can call EFL+EO Java now?

efl_io_copier_flush: add may_block and ignore_line_delimiter parameters.

The may_block parameter is useful to force a flush without blocking on
read/write, sometimes particularly useful if ignore_line_delimiter is
true, then you get the data events without blocking -- as if a server
sending some content misses a trailing line delimiter, you do not want
to block on recv() but still want to flush data to user.

The ignore_line_delimiter parameter is useful if we're going to close
the copier and want to flush pending data which may exist due missing
trailing terminator. The close method will also force that if
destination can take more data.

efl_io_copier: expose 'done' property.

This property has a protected setter and will simplify both internal
implementation as well as usage.

efl_net_server: add 'client_announce', share logic and fix a bug.

I just realized that if a client is not referenced it would leak in
the 'ssl' server as we must del it.

However, if we del the SSL socket, we're going to close the underlying
TCP. But we're from the TCP "client,add" callback and this causes
issues since "closed" will be emitted, our close callback will
unparent the client, which lead to it being deleted.

The proper solution is to only monitor "closed" if the client is
accepted. Otherwise we just check if it was closed, if we're the
parent, etc...

Fixing this in all servers were painful, we could share since most
inherit from Efl.Net.Server.Fd. Then add the "client_announce"
protected method to do it, and document how it should work.

efl_net_socket_fd: stop monitoring fd on EOS.

There was a bug that if the remote peer closed the connection, it
would trigger 'read' event, which would read 0 bytes, flagging as
EOS... but then marking as "can_read", which was wrong.

Just stop monitoring the events and fix that.

eina_slice: fix eina_slice_endswith() for same-sized slices.

elementary_test: fix function name conflict on Windows

Edje_Edit: use specific function to get file's name correctly on Win and Linux

Because '\' is dir path for linux, but '/' is dir path for Window,
so better use specific function for getting file's name depending on specific
system

elementary flip: skip unnecessary sizing.

Sizing in the constructor is wrong.
It's just a waste of function call.

edje_pick: add base_scale value to target edj from origin edj

theme: Fix 1 pixel offset and hide clipped regions

Thanks @raster for pointing this out: title bar and menu bar
were resized down to 1 pixel high rather than 0. This meant that
all CSD windows would see a 1-pixel line between the title bar
and the app content, while SSD windows would see a 2-pixel line.

Also clip out the icon, this makes a 1x1 pixel disappear from the
top-left corner.

Merge branch 'devs/iscaro/focus-event'

This series changes evas focus events, always providing
Efl.Input.Focus, making their usage way more straightforward.

Patches by Guilherme Iscaro <iscaro@profusion.mobi>
Differential Revision: https://phab.enlightenment.org/D4412

Efl.Canvas.Object: Remove focus,in/out events.

Since this object already inherist Efl.Input.Interface there's no need
to have those events reimplemented.

Efl.Canvas: Use Efl.Input.Focus as event info for object,focus.in/out.

Evas: Use events to set canvas focus in/out.

Evas: Use events to flag canvas focus in/out.

Evas: Add Focus event type.

efl_debug (client): quit if not waiting and we're done sending.

efl_debug (client): rewrite using efl_net.

Rewrite and greatly improve error checking, allow multiple commands to
be given in series, etc.

This also leverages on Efl.Io.Queue to buffer data for us, then all we
need to do is peek at its contents, when there is a full message we
use and then ask the queue to discard it.

The CLST processing was also rewritten to not allocate memory. Since
memory may be unaligned we still iterate over the buffer and memcpy()
to an integer to avoid alignment errors.

efl_io_queue: add discard method, useful in real life.

While using efl_io_queue + slice_get I found that we need to discard
data and the only way was to read to an actual buffer, kinda annoying.

Then introduce a discard method to do that.

ecore_wl2: avoid adding repeated devices

Summary:
After changes done on commit 9f8e2e0d9c9b4150
it was possible to have multiple devices with the same
id added throught the function
_ecore_evas_wl_common_cb_global_added().

To avoid such issue, let's check if the device was already
created first.

Reviewers: iscaro

Subscribers: cedric, jpeg

Differential Revision: https://phab.enlightenment.org/D4428

efl_ui_win: fix build with no support for X

efl_debug: filter own pid.

it's confusing and not helpful to report your own PID in 'list'
command.

docs: enhance efl_io_copier.

This is the core component of our new I/O subsystem, heavily used by
efl.net and the likes. Then make sure the documentation is good :-)

docs: efl_io_copier: fill gaps in eo file documentation

docs: efl_pack_grid: fill gaps in eo file documentation

docs: elm: fill gaps in separator, view_form and view_list eo file documentation

docs: elm: fill gaps in button, color, combobox and conformant eo file documentation

docs: elm: fill gaps in config, efl_ui_win and actionslider eo file documentation

docs: elm: fill gaps in diskselector, entry and gesture_layer eo file documentation

docs: elm: fill gaps in segment_control and slideshow eo file documentation

docs: elm: fill gaps in panel, photocam and progressbar eo file documentation

docs: elm: fill gaps in hover, hoversel and notify eo file documentation

docs: elm: fill gaps in systray, table, thumb and web eo file documentation

elementary: [atspi] using utf-8 text not markup text

docs: elm: fill gaps in prefs, radio, route, slider and spinner eo file docs

docs: elm_multibottonentry: fill gaps in eo file documentation

docs: elm: fill gaps in glview, pan, panes, photo and plug eo file documentation

docs: elm: fill gaps in box, grid, icon, inwin and label eo file documentation

docs: elm_mapbuf: fill gaps in elm_mapbuf eo file docuemntation

win: Disable CSD shadow if alpha and borderless

If the content has alpha, we can't ensure that the square shadow
will look good. So, hide it.

win: Fix framespace when using CSD

This was broken for X and WL after the previous patch.

win: Fix (hack around) E internal windows in Wayland

My previous patches have broken E Wayland internal windows, as
the compositor wants to create Server-Side Decorations[1] but
based on some mysterious heuristics, E will decide to show or
not SSD. It seems the surface geometry, window geometry,
input region and maybe opaque region need to all match. There
was a pixel difference in the theme which broke everything,
also CSD shadows must be turned off in that case.

This also fixes inputs as for some reason a mismatching input
region vs window geometry would break pointer move/up/down in
those internal windows.

[1] I believe this is not a great idea and E should never draw
    any server-side decorations in Wayland. Wayland was supposed
    to mean only CSD, no more SSD.

efl path: add missing value intializing.

It might be broken at some particular vector drawing.

efl_net_dialer_http: use efl_loop_fd now that it's fixed.

now that efl_loop_fd manages callbacks -> Ecore_Fd_Handler properly,
we can remove the old code.

efl_io_std{in,out,err}: do not spin on fd monitoring events.

as soon as we report 'can_read' or 'can_write', stop monitoring the
events until the user executes the operation, which will clear these
flags and we resume monitoring.

efl_net_socket_fd: fix copy & paste too much.

Edje: add checking on NULL 3-rd parameter in edje_object_part_external_param_type_get()
@fix

Summary: add checking on NULL 3-rd parameter (param) before strcmp to avoid segfault

Reviewers: cedric, jpeg, NikaWhite, myoungwoon, Hermet

Reviewed By: Hermet

Subscribers: Hermet, t.naumenko

Differential Revision: https://phab.enlightenment.org/D4424

scroller: add key action move option.

Summary:
when scroller page is enabled and key is pressed,
scroller will move in page by page.

Test Plan: elementary_test -> scroller

Reviewers: woohyun, cedric, jaehwan, raster, Hermet

Subscribers: akanad, jpeg

Differential Revision: https://phab.enlightenment.org/D4425

eo: make it possible to disable batch allocation for callbacks.

eo: when there is no more callbacks, let's clean up.

ecore: use mempool for legacy idler allocation.

efl_net_socket_fd: do not spin on fd monitoring.

If we let the user know he can read or write, stop monitoring
otherwise fd handler will constanly report of data to read/write until
its actually done, which would clear the kernel flag.

Since we use "can_read" and "can_write" for that, toggle the callback
connection that manages the actual Ecore_Fd_Handler monitor.

efl_net_server_fd: do not spin if clients can be accepted.

If we have incoming clients but we do not want to drop or handle then,
stop monitoring the fd's read, otherwise we constantly spin the main
loop.

efl_loop_fd: more efficiently manage the Ecore_Fd_Handler.

instead of always delete and recreate it, modify if it already exists
and only delete if it's not needed anymore.

This results in epoll_ctl() to modify an existing handle, instead of
add one.

efl_loop_fd: reduce number of _efl_loop_fd_reset()

When we're adding callbacks in an array, we may reduce 3 epoll_ctl()
to a single one.

efl_loop_fd: fix comparison that was breaking callback deletion.

Either we "--var" or we compare with "> 1" instead of "> 0", otherwise
callback_del will keep the flags set.

ecore_ipc: isolate legacy within ifdefs.

Compile out the legacy code when running on platforms that support
Efl.Net.Dialer.Unix and Efl.Net.Server.Unix.

ecore_ipc: fix user after free in error handling.

Fixes Coverity 1366274.

ecore_ipc: convert ecore_ipc_server_add() to Efl_Net_Server.

Each client (Ecore_Ipc_Client) is very similar to the handle
configured by ecore_ipc_server_connect() (the dialer), except we do
not have events such as "connected" and "error", as well as we don't
delete the socket as it's owned by the server, instead we close it.

The UNIX socket is configured similarly to ecore_con, setting the same
masks and mode for directories.