Summary:
2 threads run 'eo2_do(o, a(), b());'
- A goes first, creates an object, enters 'eo2_do(o, a(), b());'
in a() call, it blocks, releases B and waits for it.
- B when released, creates an object, enters 'eo2_do(o, a(), b());'
in a() call, it joins and releases A, then blocks.
- A returns from a(); and enters b() using current call stack frame,
which is the one pushed by B! then pop the frame and releases B.
- B does as above using the stack pushed by A!
Summary:
Modified syntax for eina C++ log to imitate the macro call as returning a stream. So, instead of:
EINA_CXX_DOM_LOG_CRIT(efl::eina::global_domain, "foo " << 5);
It is now used as:
EINA_CXX_DOM_LOG_CRIT(efl::eina::global_domain) << "foo " << 5;
Which more closely resambles using IOStreams in C++.
@feature
Reviewers: cedric, barbieri, smohanty
Reviewed By: barbieri
CC: cedric
Differential Revision: https://phab.enlightenment.org/D623
Summary: Evas textblock can't cut off text properly when it has separated items.
Reviewers: tasn, woohyun, raster
Reviewed By: raster
CC: cedric, herdsman
Differential Revision: https://phab.enlightenment.org/D667
It seems that a different version of freetype is causing some different
values to be calculated for some glyphs. Also, we consider the whole
font list when calculating max ascent/descent, so there will always be
differences there.
This commit just laxes the tests, requiring the values to be at least
the values we expect from our font.
Fixes T1079
Tokenizer's approach of looking back is horrible and breaks the
following simple case (bug I had that lead to this patch):
"string\\"
As the parser would get the end quote and check the previous character
if it was a backslash and it was, but it was not escaping the quote,
but being escaped by the previous backslash.
The best approach is to first check for escape and then go to
quote. Escape is simple and only the following byte, so we enter
escape, process the byte and then are back to regular mode (be it
quote or unquote).
Added testcase so we avoid breaking it again.
@bugfix cherry-pick
This happens with many texts. The issue occurs when the width of the
last char is larger than it's advance. Before this patch, we didn't the
width into account when calculating width, thus causing clipping issues
in some cases.
Summary:
Added efl::eina::malloc_clone_allocator to be used with ptr_* data
structures for wrapping structures allocated by EFL in C.
This allows for example:
void foo(Eina_List* l)
{
efl::eina::ptr_list<int, efl::eina::malloc_clone_allocator> list(l);
}
If the standard efl::eina::heap_no_clone_allocator is used, the
deallocation code uses C++ delete operator, which causes undefined
behavior because the allocation was originally done with malloc.
Reviewers: cedric
CC: savio, cedric
Differential Revision: https://phab.enlightenment.org/D614
Summary:
Added eina_log support for C++ using the following macros:
For logging into a domain:
EINA_CXX_DOM_LOG
EINA_CXX_DOM_LOG_CRIT
EINA_CXX_DOM_LOG_ERR
EINA_CXX_DOM_LOG_INFO
EINA_CXX_DOM_LOG_DBG
EINA_CXX_DOM_LOG_WARN
And for logging into the default domain:
EINA_CXX_LOG
EINA_CXX_LOG_CRIT
EINA_CXX_LOG_ERR
EINA_CXX_LOG_INFO
EINA_CXX_LOG_DBG
EINA_CXX_LOG_WARN
The usage is simple as can be seen in the tests:
efl::eina::log_domain domain("error_domain_name");
domain.set_level(efl::eina::log_level::critical);
EINA_CXX_DOM_LOG_CRIT(domain, "something went wrong with the following error: " << error);
@feature
Reviewers: cedric
CC: raster, savio, cedric, sanjeev
Differential Revision: https://phab.enlightenment.org/D605
Summary:
Added inarray, inlist, ptr_array and ptr_list's range types named: range_inarray, range_inlist, range_ptr_array and range_ptr_list.
Each has two "flavours": mutable and not mutable. The const versions are parameterized by a const parameter. For example: range_ptr_list<int const> and the mutable doesn't have the const, so: range_ptr_list<int>.
The difference between the two is that the const versions can't modify the elements from the sequence, while the mutable allows so. Also, the const receives a Eina_Array const* while the mutable must have a Eina_Array*.
Reviewers: cedric
CC: savio, cedric
Differential Revision: https://phab.enlightenment.org/D613
Summary:
Added support for exceptions on ecore_main_loop_thread_safe_call_async and
ecore_main_loop_thread_safe_call_sync. Also optimized the transport of the
return value through a parameter on ecore_main_loop_thread_safe_call_sync.
ecore-cxx: Changed uses of alignas for aligned_storage in C++11
Reviewers: cedric, raster
CC: savio, cedric
Differential Revision: https://phab.enlightenment.org/D593
Signed-off-by: Cedric BAIL <cedric.bail@samsung.com>
The current implementation of eina_convert_itoa cannot convert INT_MIN.
When the input number is negative, the function negates it and this is
an undefined behavior for INT_MIN since -INT_MIN cannot be represented
in a signed int.
@fix T1062
Signed-off-by: Cedric BAIL <cedric.bail@samsung.com>
as we don't support multiple composites of the same class,
and know at class elaboration how many composites we should have,
we can create the composites array and pack it at the end of the object.
In a previous commit I mentionned that make check would fail
if PulseAudio is not running. Well, this is a bit excessive,
especially for buildbots where it doesn't have to be running.
So let's check that PulseAudio is running before failing.
Other errors should still be caught.
A simple "pulseaudio --check" should do the trick.
EFL can be built with PulseAudio support even if PA is
not present on the system. In that case, ecore_suite will
hang forever. Let's just catch the error instead.
Note: make check will fail if PA is not available (but not hang)
This is not related to Tom's recent mail (but yeah it reminded me
of this bug^^)
Fixes T732.
The point of this binding is to enable the support for easy lambda for ecore function
that wont be using Eo. See the tests on how to use those.
Reviewers: cedric, raster
CC: savio, cedric
Differential Revision: https://phab.enlightenment.org/D582
Signed-off-by: Cedric Bail <cedric.bail@free.fr>
eo_composite_attach fail if the class of the composite is not
listed in the parent class extensions, or if there is already a
composite of the same class. The later because calls are
forwarded to the first responding composite, see _eo_op_internal().
The goal of this library is to make the life of C++ developers easier
when having to manipulate Eina datatype by providing a layer to abstract
those data type in C++. Check examples for now. Documentation will come
soon, but we are pushing that rather sooner to get feedback on those bindings.
As you will notice, this library is just composed of headers. There is no .so
and we do think it is better this way. Reducing ABI and API stability issue for
applications developers who are the primary target of this binding.
Also please note that you will need to have C++11 to use this binding.
Signed-off-by: Cedric Bail <cedric.bail@free.fr>
* New --loop: restart the playback when end reached
* New --position: start the playback from the last know position
* Fixed double -R option. now -r is --reflex and -R is --copyright
Loop and last-position was implemented yet, this commit just made
them optionally, so the default behaviour of the test reflect the
default behaviour of emotion.
Force render into an Ecore_Evas, and check that the pixels
are valid:
- Not all transparent (can't really happen)
- Not all black (since there's a black rect behind the text)
- All valid premultiplied values (A >= R,G,B)
Yes, it's a bit slow. But at least it really checks something :)
Set filter on a text object and check the object's geometry.
Get the padding and the geometry so we're sure they match.
Also, pad_get would return 0 if the filter did not compile,
so this checks that these filters are valid.
This test uses some Devanagari text that should have more complex
clusters than what latin text can provide. This is a more complex
wrapping case that should be tested and haven't been tested until now.
NOTE: do we really need to maintain 2 different groups for the reflex effect?
The 2 groups differ only for the added reflection part.
Isn't enough to show/hide the reflection part when requested?
Summary:
delete_cb is called at thread exit for each Eina_TLS keys used by the thread
Details:
posix:
pthread_key_create(key, delete_cb); does it
win32/wince:
eina_tls_free/new un/registers key&&cb into a static eina_list.
eina_tls_set add the key to an eina_list in Eina_Thread_Win3.
this list is cleared and callbacks are called in _eina_thread_join()
Test Plan: win32/wince has to be tested, I have no setup to do it.
Reviewers: cedric
CC: cedric
Differential Revision: https://phab.enlightenment.org/D489
It is sometime useful to start from a defined buffer, but to not touch it
until needed. This make life of caller more easier as they don't need to
duplicate the buffer themself as Eina will now take care of that.
In the previous commit, style padding has been changed, so
that lines don't get extra space just because there's a special
style (glow, ...)
This adds some test cases that check the actual geometry of the
lines relatively to each other.
NOTE: This test does not fail before the padding commits, as
_relayout_if_needed() adjusts the padding properly.
This patch will detect how many more times ecore_init was called
during initialization and use that as a threshold to do a clean shutdown.
It is a necessary evil as we do have ecore module that will initialize
eldbus that will then reinit ecore_init from within ecore_init and without
a chance for the application to act on it.
I also reenable a test to make sure we will catch earlier this kind of issue.
This patch is necessary to work around the fact that if you have some
ecore system module installed, they will be initialized and may use another
library like eldbus that will call ecore_init again. So ecore_init will be
different from 1, but still be a success.
My patch does introduce a work around a problem in that situation. Calling
ecore_shutdown wont work at this stage, as we do have module that did initialize
ecore also. And the only way to make ecore_shutdown happen is to unload those
module and that wont happen as they where initialized from inside ecore... lala !
Yes, we never shutdown ecore properly when we have ecore module that use
something like eldbus.
Ecore system module may use dbus, so when you init ecore, it may init eldbus a few
more time (depending on the module that are present on your system). This result in
eldbus_init returning a valid init, but different from 1. This patch update the test
to take that into account.
Summary: Added a test for range_text_get case on the text that include multi text node.
Reviewers: tasn, woohyun, seoz
CC: cedric
Differential Revision: https://phab.enlightenment.org/D398
Jérémy Zurcher
Tom Hacohen
Felipe Magno de Almeida
Yossi Kantor
Youngbok Shin
Cedric BAIL
Jean-Philippe Andre
Gustavo Sverzut Barbieri
Sylvain Laperche
Jean-Philippe ANDRE
Davide Andreoli
Carsten Haitzler
Shinwoo Kim
Sebastian Dransfeld