elementary: prevent double free

This one is a bit tricky... When we create the aggregated
promise, if one of the properties of the model returns an
error, the eina_promise_then() will immediately call the
error callback. In this happened for the first item, the
total items in the listing request would be 1.

Before this commit, we tested for incremented the processed
counter and compared it to this total count. If it was
greater or equal, we would free the common listing request.
But in the case of successive failures, we would set the
total counter to 1, then the processed counter to 1 and
therefore free. Then increment the total counter to 2, then
then processed counter to 2, and free again... which would
cause an abort() from the libc or something else nasty.

Now we just decrease the total count of items. We avoid
the cases and double frees, without leaking.

elementary: make sure we don't iterate out of bounds

The carray iterator will end iterating only when it finds a NULL
object. We must make sure the last element of the array is NULL
to avoid out of bounds access.

eina: overhaul Mac OS X semaphores

Mac OS X does not support POSIX unnamed semaphores, only named
semaphores, which are persistant IPC: when the program exits,
and if semaphores where not released, they stay forever...

All EFL programs were "leaking" a semaphore, due to how
eina_log_monitor manages its resources. Therefore, after building
EFL a lot (which run eolian_gen, eolian_cxx, elua, edje_cc, ...)
we were not able to create any semaphore...

Now, we get rid of these semaphores and use Mac OS X's own
semaphores. Code is less cumbersome, and we don't have any
disavantage of the named semaphores.

Fixes T4423

@fix

eo: speedup efl_isa by 50%.

Most of our use case of efl_isa is related to legacy Evas_Object_Image API,
that check the isa of the same object again and again. Caching help.

eo: general speedup of all Eo related operation.

This change rely on the fact that we do fetch the same
object id over and over again. _efl_object_call_resolve got
15% faster, efl_data_scope_get 20%.

eo: remove useless duplicated check.

Efl Object: remove legacy callback calls from event_callback_call

Efl.Object.event_callback_call no longer calls legacy smart callbacks;
calling only event callbacks registered with the given event description
pointer.

Create the method Efl.Object.event_callback_legacy_call to inherit the old
behavior from Efl.Object.event_callback_call, calling both Efl.Object events
and legacy smart callbacks.

Update all other files accordingly in order to still supply legacy
callbacks while they are necessary.

ecore_cocoa: fix fullscreen for older osx versions

Tested on 10.11 and 10.9.

Fixes T4395

ecore_cocoa: refactor resizing request

ecore_cocoa: fix memory leak

Elementary: Genlist Tree Test - Add an item with the indent style to match tree style.

Elementary Theme: Add  "indent" genlist item style.  This style allows non tree items to match tree items.

efreet: add doc note about stringshare reliability for efreet_mime_type_get()

elm: Show code widget width marker after the column

Provide a clearer indication of what width is available

docs: add an option to disable title plugin usage

docs: let the writer handle title headings

docs: generate proper title for all pages

docs: add writer support for pagetitle plugin

elm: Fix some ERR messages following previous patch

This simply avoids calling functions on NULL objects, since
the previous patch would ERR out rather than silently ignore
the problem.

I just add explicit NULL checks before calling the functions,
so it's clear the object could be NULL (in the widget).

evas3d examples: Add EFL_EO_API_SUPPORT where needed

I might have broken this in a previous commit in evas headers,
but the thing is that beta does not imply eo api, so both are
still required.

evas events: Add efl_isa safety checks in legacy EAPI

This removes useless magic checks (only check whether the
arg is not null) that were not even present in every function.
The cost should be similar or lower than an eo function call.

efl: Rename Efl.Event.XX to Efl.Input.XX

This removes:
 Efl.Event interface

And renames:
 Efl.Event.Input -> Efl.Input.Event
 Efl.Event -> Efl.Input.Event (merged)
 Efl.Event.Pointer -> Efl.Input.Pointer
 Efl.Event.Key -> Efl.Input.Key
 Efl.Event.Hold -> Efl.Input.Hold

This also moves some interfaces from efl/ to evas/ where they
belong better.

This allows renaming Eo_Event to Efl_Event.

evas: Add normalized and window coordinates to axis events

This is for Wacom graphics tablets (with a pen).

The raw data sent by ecore to evas (and then to apps) is pretty
useless as it's not normalized, and apps have no way of knowing the
dimensions of the tablet, without themselves opening the device
(we don't know nor expose the path to the device).

This is for Xi2 only for now, as Wayland support hasn't been done
yet.

The intent is to deprecate LABEL_X and LABEL_Y. I'm not sure yet
if the normalized value is useful or not (it would seem we may not
be able to provide this info in Wayland).

The new WINDOW_X, WINDOW_Y labels will be used in the new event
type (Efl.Event.Pointer). Normalized values are not exposed yet,
let's decide if we want them or not first (based on what can be
done in Wayland space).

@feature

evas: Simplify internal evas_object_event_callback_call

This removes the distinction between legacy and new eo style
event info, since all those types have now been ported to eo.

ecore xi2: Discard "axis" inputs from standard mice

Mice in X with xi2 send Axis events which are badly defined,
and carry basically useless information, as we also receive
proper mouse events. Notably, all mice input events are
"Rel something" but in fact they are absolute values (even
the wheel information is a counter increasing every time you
scroll).

This should not break any application as such axis events
carried only values with label ECORE_AXIS_LABEL_UNKNOWN.
This also fixes a leak when n == 0 (no "valuator" found
in the list, this used to be unlikely, now happens at every
mouse event).

evas events: Switch axis events to the new eo type

This converts Evas_Axis or Ecore_Axis info arrays into basic
pointer data. Also marks those fields as set. All events need
to properly implement the value_has property (mark all bits
whenever a value is known).

evas events: Rename properties and introduce generic value

This paves the way to a merge of pointer and axis events into
the class Efl.Event.Pointer.

evas: Optimize out most callback call events

This sets a bit whenever a callback listener is added.
I couldn't get any profiling data easily (too small for
valgrind).

Note: This removes the proper refcounting on the "move"
event listeners. I believe this is not a problem as most times
the move_ref goes to 0, it is because the object is deleted.
Worst case, we just trigger a callback_call with no listeners.

This adds 32 bits to each evas object private data.

evas: Move event catcher to evas_callbacks.c

No functional change.

evas: Remove deprecated events from public EO class

del and free eo events don't need to be exposed, even as beta
API. They are still required for legacy callbacks.

elm,evas: Remove use of EFL_CANVAS_OBJECT_EVENT_DEL

This event should not be exposed at all, it's not necessary
anymore, EFL_EVENT_DEL already exists and should be good enough.

This does move the callback call a little bit ealier in the del
process, but at first glance, this shouldn't have any impact.

evas events: Add new "finger,move/down/up" events for multi touch

This moves MULTI events to those new finger event types,
and also sends a finger event for finger 0 (aka the pointer).

NOTE: This may require a separation between a mouse input and
      an actual finger touch. To be defined, ie: do we let the app
      check the input device info to decide whether the event is
      actually the first finger of a multi touch device, or do
      we want to send only actual finger events from multi touch
      devices only?

@feature

evas events: Simplify event counter

Simplify code:
 _evas_object_event_new()
 event_id = _evas_event_counter

Into:
  event_id = _evas_object_event_new()

evas events: Remove now unused code

evas events: Fix crash when translating legacy events

An obvious crash happened when reusing a legacy struct
from another type.

evas events: Switch mouse move events to the new type

This is the last commit for this crazy input transformation
series. The following commits will be cleaning up now
unused code, and fixing bugs.

evas events: Switch multi move to new event type

Now only the single move remains. Almost done!

evas events: Switch multi up/down to the new event type

evas events: Switch mouse in/out events to the new event type

evas events: Switch mouse move event to the new event type (1)

This only modifies the proxy source handling code.

evas events: Switch mouse up/down to the new event type

This is getting trickier, as those events have a lot more
side effects and complexity than a simple wheel event...

Some code has been added that should be fixed in the following
commits.

evas events: Switch key up/down event to new eo type

evas events: Switch hold event to new eo type

Evas_Event_Hold is now barely used anywhere.
This also adds support for event_flags to this type.

evas events: Switch wheel event to the new type

For now this covers only the wheel event.

Note: This patch also modifies evas map to use double in an
internal function, rather than ints.

eina: readdir_r has been deprecated.

So glibc has decided that readdir_r is hard to use safely and deprecated it
this summer. They recommand to use readdir, which was in the past unsafe to
use in a multi thread scenario, but is now on most system (and all system
we care, including our own implementation in evil). It is basically safe
as long the same DIRP is not accessed from another thread. This is true in
our code base, so we are fine to go with this.

For further reading: https://lwn.net/Articles/696474/

evas-gl_cocoa: migrate to gl_generic infrastructure

It has been a long journey, but here we are at last...
The infamous gl_cocoa engine has been migrated to the
gl_generic infrastructure. This should provide great
improvements and hopefully reduce side-channels b0rkage.

Fonts seems better, scrolling is smoother, expedite
does not segfault anymore... I haven't found a
regression with elementary_test, elementary_config,
terminology, expedite.

evas-gl_cocoa: start refactoring for gl_generic

evas-gl_cocoa: remove unused code

evas-gl_cocoa: cleanup eng_setup

evas-gl_cocoa: cleanup eng_info

evas-gl_cocoa: init/shutdown cleanup

configure: Enable elput if wayland is requested

This makes ./configure --enable-wayland work without having to
specify --enable-elput.

evas: Try harder to create the render thread

It's entirely possible that a system doesn't have a cpu 0, so
when we try to pin all our render threads onto processor 0 we
may fail.

This results in some very connfusing build breakage when
edje_cc hangs up because its render thread didn't start.

So, if starting the thread with affinity fails, let's try without
affinity.

(This is trivial to reproduce - just use sysfs to turn off cpu0
after boot.)

@fix

efl_net_dialer_http: use the proper error code

CURLcode is for curl_easy, while CURLMcode is for curl_multi.

Thanks to clang that spotted it.

efl_net: better handling for SOCK_CLOEXEC.

On systems where SOCK_CLOEXEC is supported, give it to socket() and if
accept4() is supported, then use it as well.

Otherwise revert to fcntl().

Revert "ecore_con: use F_CLOEXEC instead of SOCK_CLOEXEC"

This reverts commit 99d37838f32ef33b805bcefc7dc0320cfda05a0a.

will be fixed in a better way with the following commit.

Static deps unibreak: Update to latest git version.

This version reduces the number of dirty pages used by libunibreak.
Reference git hash: ad5a524b0128eec644a8cae52fb75ed1f597c0ee

@feature

Fix elementary build when xkbcommon is in a non standard location

@fixes T4413

evas: Fix includes when enabling BETA but not EO API

This fixes the build for older versions of E.

ecore_x: Early check image bpp based on depth

This fixes argb windows transparency in E software compositor.

My current problem is that I have no idea what changed, why this
is needed now, and how things could actually work before.

Fixes T4389

@fix

efreet - convert crash into NULL mimes when no mime db found

so ok - efreet crashed letting you know you have a missing mimedb...
return NULL instead fixes T4425 :) - rememebr to kill your efreetd's
to get a new mimedb - log out and in will do that.

efl_io_queue_example: use eina_slice_endswith().

make the code more readable and clear. Also document when the line may
miss a trailing line delimiter in the slice.

eina_slice: startswith and endswith.

these helpers around memcmp() make the code more readable.

efl_io_queue: basic class to interact with Efl.Io interfaces.

The use of low-level interfaces such as Efl.Io.Reader and
Efl.Io.Writer are not that user-friendly as they can handle partial
data.

Classes such as Efl.Io.Copier makes them easy to use, but they need a
reader (source) or writer (destination) and in our examples we used
fixed buffers or some existing streams (stdin/stdout/stderr,
networking...).

However, if interactively we need to produce some data to be sent,
such as implementing some networking protocols, we'd have to write our
own Efl.Io.Reader and Efl.Io.Writer classes to handle the buffering.

Not anymore! With Efl.Io.Queue you can write stuff to it and it will
buffer to memory. Once stuff is read, it will automatically remove
those bytes from buffer.

efl_io_copier_example: set loop as parent for Efl.Net.Dialer.Tcp

although it was working, the correct way is to set a loop provider as
Efl.Net.Dialer.Tcp object.

efl_io_buffer: do not refer to sub-classes in its docs.

depending on the order of generation eolian was triggering some
errors. So stop refering to subclasses here.

efl.io.buffer: minor bugfix.

if no limit was set, do not resize buffer to 0.

eina_slice: fix multi-byte find function, add tests.

wayland_egl: Destroy gl context if engine info updated with NULL wl_surface

We set the wayland surface to NULL in engine info, then destroy the wayland
surface later.  The GL stack tries to render to the destroyed surface and
dies.

If we destroy the GL surface when we set the engine info (before we destroy
the wayland surface)it stops the GL stack from doing bad wayland calls.

This fixes a crash on exit, or when any window closes when using mali GL
drivers.  Surprisingly, Mesa was tolerant of this.

eina: remove references to win32 and winCE in threads

autotools: remove win32 threads artifacts

Commit 2cb0c1cadc46e1d89fea4e27399b36ce9f1526ff removed
the use _efl_have_win32_threads, but some traces of it
were left.

eina: fixtures on OSX semaphores

So actually there is quite a big issue with semaphores
on OSX. We use (named) POSIX semaphores, but this was
a (my) mistake... I'll fix it later...
The real issue is that named semaphore are persistants:
when the program dies, it stays alive. This is pretty
bad with eina_debug_monitor because we create a semaphore
we never release, due to a wild thread...

This leak of semaphores went unnoticed before commit
4a40ff95defa5fa7e6164459c50e674b53cddaf4 because the
name of the semaphore was unique per process, and
overriden when another process was launched. This
was very bad, but saved us from overflowing the
semaphore pool. It is now overflowed pretty fast when
building a lot EFL, because of Eolian that runs A LOT!

So that's one problem that still needs to be fixed,
by using OSX' own semaphores (see T4423).
Another big issue, which is now fixed is that the
buffer in which we generated the semaphore ID was
too small, and therefore we were reduced to one shared
semaphore for a whole process... This buffer has been
now set to 31 characters, which seems to be the maximum
length of a semaphore ID.

So now things are better, but still with a deadly issue.

evas: handle thread queue creation failure

eina_thread_queue_create() might fail.
Actually it does fail on Mac OS X under
some circumstances.

eina: fix eina_btlog for older osx versions

Older Mac OS X deprecated the default atos.
This patch adds support for Mavericks (and
maybe Yosemite as well).

ecore_con: use F_CLOEXEC instead of SOCK_CLOEXEC

Mac OS X does not provide SOCK_CLOEXEC. Instead, we can use
fcntl() with F_CLOEXEC.
Fixes Mac OS X build.

ecore_con: fix compiling on OSX and BSD

TCP_CORK is Linux only. TCP_NOPUSH is supposed to
do the same thing than TCP_CORK, but on BSD (including
Mac OS X).

We now check for the existance of TCP_CORK or TCP_NOPUSH,
and use the right option. If none exist, cork_{set,get}
will just fail.

autotools: add macro to easily check for defines in headers

FDO icons: correctly list the intl icons in theme description file

@fix

examples: add efl_io_copier_simple_example.c

a simpler example to be listed in wiki.

Efl object: Remove creation of event structure and passing it to eo.

This was never used and will probably never be used. It was just wasting
memory and making things more complicated.

Just to give some more concrete numbers, this change alone reduced the
number of dirty pages used by elementary by two. So quite significant.

BREAKS ABI

@feature

Eolian: Fix tests according to recent eolian changes.

eolian gen: don't generate events in eo.c

Efl object: Don't pass events to eo class creation.

This was never used and there is no plan to ever use it. I'm going to
soon add a different mechanism with which it will be possible to provide
them again to Eo if ever needed without breaking ABI. Though it's
unlikely it will ever be.

remove EINA_ERROR_TIMEOUT

As pointed out in the mailing list, it was introduced in this release,
so it's better to remove the symbol instead of deprecating it.

People should use ETIMEDOUT directly.

eolian: enforce no get/set as method/property name rule

Fixes T3849.

eolian gen: include return type in event docs

Fixes T4393.

elm_entry: Add more description about key event in return_key_type_set

Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

ecore_imf: Add more description about key event in return_key_type_set

Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

elput: Fix typo in doxygen

Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

efreet - save about 240-300k or so of memory used by efreet mime

so efreet mime was loading a bunch of mime type info files, parsing
them on startup and allocating memory to store all this mime info -
globs, mimetype strings and more. all a big waste of memory as its
allocated on the heap per process where its the SAME data files loaded
every time.

so make an efreet mime cache file and a tool to create it from mime
files. mmap this file with all the hashes/strings in it so all that
data is mmaped once in memory and shared between all processes and it
is only paged in on demand - as actually read/needed so if your
process doesnt need to know about mime stuff.. it wont touch it anyway.

this saves about 240-300k or so of memory in my tests. this has not
covered the mime MAGIC files which still consume memory and are on the
heap. this is more complex so it will take more time to come up with a
nice file format for the data that is nicely mmaped etc.

@optimize

efreet - fix efreet_*_dir_get() to support the xdg env vars

these api's didnt respect the env vars xdg dictates should override
the xdg dirs for that process. this fixes this and uses them if set

@fix

fixup: http

fixup: http

fixup: efl-net

WIP: efl.net: Introduce Efl.Net.Dialer.Http

This class implements the Efl.Net.Dialer interface using libcurl to
perform HTTP requests. That means it's an Efl.Net.Dialer,
Efl.Net.Socket, Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus
being usable with Efl.Io.Copier as demonstrated in the
efl_io_copier_example.c

efl.net: socket, server and dialer for TCP.

Efl.Net.Server defines how to accept new connections, doing the
bind(), listen() and accept() for protocols such as TCP.

Efl.Net.Dialer defines to to reach a server.

Both are based on Efl.Net.Socket as communication interface that is
based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being
usable with code such as Efl.Io.Copier.

The Server will emit an event "client,add" with the established
Socket, which is a child and can be closed by both the server or the
user.

The Dialer extends the Socket and allows for creating one given an
address, that will be resolved and connected.

TCP is the initial implementation so we an validate the
interfaces. UDP, Unix-Local and SSL will come later as derivate
classes.

The examples are documented and should cover the basic principles:

 - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a
   "netcat", can send data from socket, file or stdin to a socket,
   file, stdout or stderr.

 - efl_net_server_example listens for connections and can either reply
   "Hello World!" and take some data or work as an echo-server,
   looping back all received data to the user.

More complex interactions that require a "chat" between client and
server will be covered with new classes later, such as a queue that
empties itself once data is read.

efl.io: introduce basic interfaces and classes.

These interfaces allows generic operations on objects that can store
or provide data, such as a file or a buffer.

With well defined interfaces and events we can create code such as
Efl.Io.Copier, that will link a source with a destination and
progressively copy data as they appear.

binbuf, strbuf and ustrbuf: add slice_get() and rw_slice_get().

eina_stringshare: add slice_get()

eina: introduce Eina_Slice and Eina_Rw_Slice.

A plain simple pointer + length describing a linear memory region.