After ecore_shutdown the main loop is dead, so the flag do_quit can be
safely reset to 0. This will fix issues with cycles of
elm_init/shutdown. This fixes:
CK_FORK=no tests/elementary/elm_suite elm_win
This patch relies on a few of the previous patches which ensure that
ecore is well shut down.
@fix
It's not enough to check the init generation count, if the cache data is
not reset properly.
This patch adds safety in two ways:
1. Actually reset the op call cache when we detect a new generation
2. Verify that we don't return NULL function pointer
The 1st point is absolutely necessary, 2nd is optional (extra cost of
one if()).
@fix
An old comment mentioned that this was explicitely not unregistered, but
I believe the comment isn't valid since ecore_event_type_flush() was
introduced.
ecore could not shut down properly in an elm_init()/elm_shutdown()
cycle, with 7 remaining references, all because of a typo.
This should help @cedric as well
The incomplete reset (array to NULL but max not reset) triggers errors
in evas_thread_queue_append() where eina_inarray_grow() returns NULL.
This shows up in:
CK_FORK=no elm_suite
@fix
Somehow I was seeing a ton of errors with "prefs_iface" not found in
make check. This code could not have worked since the merge of
elementary in EFL tree...
@fix
Summary:
elm_bg was supposed to be used only in legacy,
but since we need a common object to be used as a background of widgets,
it is now renamed as efl_ui_bg and supports EO APIs.
Reviewers: cedric, jpeg, woohyun
Differential Revision: https://phab.enlightenment.org/D5147
This removes the last remaining legacy-style part API from Widget.
I think this is redundant with the property "translatable_text"
introduced in Efl.Ui.Translatable.
Ref T5363
This moves the API entry points from Widget to Layout parts. I don't
think the other widgets support translation, but that is easy to fix.
The actual code implementation remains in elm_widget.c.
Legacy-only widgets are covered by Part_Legacy, while all EO widgets
that have text inherit from Layout (except Win but I don't think the
window title was translatable in legacy).
This removes 2/3 remaining part APIs from Widget.
Ref T5363
This will be used to replace the part translation API in Elm.Widget. It
should work for both parts and non-parts (ie. the main text of a button,
for instance).
For now I'm taking the following approach:
- All efl_text_set/get strings are untranslatable, i.e. get() returns
the visible string, set replaces and can not be translated.
- translatable_text_set/get needs to be used to enable automatic
translation, which in turns calls efl_text_set to modify the visible
string. Thus, translatable applications will have to use
efl_ui_translatable_text_set a lot more than efl_text_set, unless
they translate strings application-side.
Note that some other frameworks take a simpler approach equivalent to
calling efl_text_set() with an already translated text. This prevents
runtime language changes of the application, unless the application
handles them specifically.
This is a follow-up to 4d4401f3a6.
The format line adjustment (e.g. linegap) should calculate the current
item's ascent/descent, and then update c->ascent/c->descent.
Otherwise we accumulate calculations like linegap values
ref D5217
Since elm_popup_item.eo.h is only included in elc_popup.h, the EAPI is
not well defined, resulting in a crash when, in a simple C file, the
item class is tried to be accessed.
By including the H file in elc_popup_eo.h, we make it public (as the
other item classes) and solve the EAPI issue.
Thanks @jpeg for helping me to solve this issue.
Summary:
Textblock uses ascent, descent from primary font when there is no text.
If a text is set which need other font, Textblock uses ascent, descent from
actually loaded font. If loaded font has smaller size, text cursor and text
looks jerky in elm_entry. At least, primary font's size should be respected
as minimum size of a line for avoiding this issue.
In addition, the patch will allow negative line gap values.
@fix
Test Plan:
Put your hamburger(🍔) in Ecrire. And put an english character.
(Put a text which will load smaller font. And put a text which will load primary font.)
Reviewers: raster, cedric, herdsman, jpeg, woohyun
Reviewed By: raster
Differential Revision: https://phab.enlightenment.org/D5217
Summary:
When evas selects a strike of embedded bitmap font,
calculate ratio and use it for scaling embedded bitmap.
@feature
Reviewers: jpeg, tasn, woohyun, raster, herdsman
Reviewed By: raster
Subscribers: charlesmilette, Francesco149, cedric
Differential Revision: https://phab.enlightenment.org/D2713
pause event means that the window is not visible anymore to any user.
resume is triggered when the window became visible again or just
became visible again.
pause event is triggered when no more windows are visible to any user.
resume event is triggered when a window make the application visible
for the first time to the user after a pause or when starting the application.
Thanks @JackDanielZ for the report!
This makes efl_content_set/get/unset APIs work on the inwin, even though
this is a legacy-only widget (at least right now).
These types are of questionable value and the API was not entirely
thought out - remove for now, and if a legitimate use is found
later, they may be readded (with a better API), but typically it
seems best to redesign the bad APIs around safe containers...
This is a new type representing a mutable string (no const).
Regular strings cannot be made mutable with @owned because
they might be hidden behind typedefs.
in some cases loading an xmodmap on enlightenment startup can trigger an infinite
number of identical events which hard locks the xserver for a very, very long time
@fix
This relies on the new edje API that gives us the exact type of a part.
This fixes the shortcomings of edje_edit_part_type_get() and returns a
proper Text part type for efl_part(slider, "elm.units.max").
See previous commits:
"edje: Add part_type_get API"
"elm: Split off text and content for efl_part"
For now I made this EO-only but this definitely could be expose in
legacy API as well.
This simply gives exact information about the type of part, after doing
a recursive search. Edit Edit doesn't do a recursive search, only a
direct one, which can yield invalid results (eg. RECT or NONE instead of
TEXT in case of "elm.units.max" for a slider).
@feature
The string comparison was invalid for full part names. It worked with
the aliases, by chance, not by design.
This got broken by eee60abbcf but using full part names from the
application side was already broken before that.
@fix
Reasons:
- This API has been confused with the min size of the widget, resulting
in badly laid out applications.
- The EO API was not very nice (Range is about numbers, the Gfx size
hint in a part is really ugly).
While I understand the value of this API and how it can be used in
scalable applications, it is in fact not absolutely necessary.
Alternatively to that span size, the widget min size can already be
defined from the application side, or the widget can simply be expanded
to fill in its parent.
This can obviously be reinstated later if the need arises for EO. For
now, keep this feature as legacy-only.
This is VERY tricky.
For legacy, just create an internal class that has both. It's easier
this way. For parts that are handled by Layout directly, we know from
Edje which type to return.
For EO objects we should know from the part name which kind of part we
are dealing with:
- text (overridden by the widget)
- content (overridden by the widget)
- special (new efl_part based functions)
- generic (handled by Layout)
Note: Efl.Ui.Slider was handling "span size" on ALL parts. That's bad...
This is now limited to "span" only.
This means that ALL part handles inherit from the base part class
Efl.Ui.Widget.Part. Layout is the only exception where Efl.Part is
specially overridden.
This is a first step towards generic part APIs, including background in
all widgets.
Adds "Efl.Ui.Text_Async" object.
This new widget uses the "async_layout" functionality of the underlying
Efl.Canvas.Text object.
Currently, if "editable" mode is enabled, there is no asynchronous
layout, as interactive operations (e.g. typing) should get processed
immediately. Thus, only "non-editable" instructs the text object to do
asynchronous layout.
@feature
This adds the 'async_layout' method.
The 'async layout' method is similar to 'size_formatted_get', but done
outside of the mainloop. When a call is made to this method, a thread
is created (after some preparation like updating the logical text
items), and the visual layout is offloaded to that thread. The result
is returned as Eina.Future.
The mainloop is blocked for operations that manipulate the object, if a
thread has already been created but hasn't complete its work.
Consecutive calls for async layout for the same object are not handled
simultaneously. Each time the threads has complete its work, the next
(if exists) layout will be dispatched.
@feature
the content unset in some cases - specifically terminology seems to
put the item back in and doesnt remove it... causing it later to be
deleted if unset to remove it and re-use it (which is rarely done).
@fix
I think this closes the orientation vs. direction problem.
RTL vs. AnyRTL is not fully handled yet but this becomes a
widget-per-widget issue (eg. should a box in a RTL locale be mirrored if
set to horizontal?).
Fixes T5870
Summary:
Tile is common type which can be used eg: background.
This is added to scale type which can be set/get by
efl_ui_image_scale_type_set/get()
@feature
Test Plan:
Run elementary test
Run Image Scale Type
Check radio "Tile".
Reviewers: jpeg, cedric, woohyun
Differential Revision: https://phab.enlightenment.org/D5119
Summary:
When multi down or multi move occur, state of touch point changes to EVAS_TOUCH_POINT_STILL.
So I add condition, "state == EVAS_TOUCH_POINT_STILL"
Reviewers: jypark, woohyun, cedric
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D5157
Summary:
If user call tooltip_orient_set or tooltip_style_set or tooltip_window_mode_set
before tooltip_test_set or tooltip_content_cb_set, those functions doesn't work.
Because elm_tooltip will be created when tooltip_content_cb_set is called.
I fixed logic to use some functions before tooltip_test_set or tooltip_content_cb_set.
Test Plan: elementary_test -> Popups -> Tooltip
Reviewers: jpeg, Jaehyun
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D5183
Summary:
If the object is outside the parent geometry because of map,
this object would be ignored in determining object is in the event area.
Please refer to below case
1) There are some button in the box object
2) A button has map with 90 degree.
It would be placed outside the box geometry
3) If you press the button part outside the box,
the button event does not work.
Test Plan: sample code
Reviewers: jpeg, cedric
Differential Revision: https://phab.enlightenment.org/D5180
Summary:
In elm_map_overlay_show and elm_map_overlays_show,
it frees overlays list members. This lists are used
in elm_map_overlay functions, so should remain.
Test Plan:
1. Run elementary_test -> Geographic -> Map
2. Click group overlay (whose text is "3") -> bubble appears
3. Click "Show" button -> observe no more Eina Magic Check Failure appear.
Reviewers: jpeg, cedric, woohyun
Differential Revision: https://phab.enlightenment.org/D5191
This fixes scrolling in rage.
Lessons learnt:
- Do not trust raster's bisecting skills ^^,
- Do not blame GCC until you're 100% positive about the exact code
triggering an issue,
- va_arg is unsafe, and can lead to crazy issues like this one,
- va_arg passes (int x, int y) differently from Eina_Size2D sz, and
optimization flags may also affect how that's done, or at least what
kind of garbage data is used.
We're not 100% sure yet but there seems to be an issue with GCC and -O2
where rage scrolling doesn't work anymore, since the first patch below:
See 641a58f735
See f53fe993a6
This commit unfortunately doesn't solve the issue.
Function declared in a .eo are something that we want to allow people to inherit from
or use in a binding. I can't think of a situation where that would be the case for
this function and it solves at the same time problem of needing a shared interface
for both loop and loop_user.
The "default" name doesn't mean a lot to edje. Use the helper function
to get the proper seat name.
This fixes IMF for the Entry widget, that did not get triggered on the
hotkey combination.
@fix
The seats list got emptied, but the counter progression was kept,
causing needless different seat names for the same device across
different edje objects.
the error case is when a element is shown, but its parent was not.
In that case intersect returns immidiatly, without evalulating the focus
state again.
calc_size_min was just a helper passing 0,0 to the restricted form.
Let's not duplicate APIs in EO and use an optional argument instead.
Bindings should be nicer and C could use a macro if it's too cumbersome
to pass in 0,0.
For this patch I decided to add a pseudo legacy wrapper as the function
is called in a very large number of places. Fixing all those calls to
use the size2d form is a lot of work and a greater risk of b0rking
something.
It's a complex struct but defined in EO as a simple struct. ABI-wise
it's equivalent to Eina_Rectangle. Some macros that use Eina_Rectangle
also work on Eina_Rect out of the box, most of the code dealing with
x,y,w,h will require no modifications either.
But Eina_Rect provides direct access to a size or position 2d component,
as well as the usual x,y,w,h. The field "rect" is provided as a
convenience for code dealing with both Eina_Rectangle and Eina_Rect. We
may or may not require it.
Note: Size2D could use unsigned values but I have spotted a few places
in the code that actually use -1 to indicate invalid size (as opposed to
0x0).
@feature
Reported by @jiin.moon:
In case of async_open for an elm_image, we try and open a file in a
thread, then map it and populate a bit, as this may take some time
(blocking I/O). This creates a mmap with eina_file_map_new. But later
evas image loaders will (usually) try and map the entire file with
eina_file_map_all() which creates another mmap. Since the size is
different (32Kb first then all) the returned map might be different
(it's up to the kernel to decide at this point).
So, in order to avoid having multiple maps on the same file, and try to
reduce the peak memory usage, we should prefer using the same map all
the time, i.e. the global one returned by eina_file_map_all().
This patch relies on the previous patch in eina_file which fixes
eina_file_map_populate() for the global map.
@fix
This makes sure that the call to madvise is safe. On Linux it's not too
much of an issue as checks are made inside madvise, and the worst that
can happen is an error is returned (EINVAL). Not great.
But if MAP_POPULATE is not present, as is the case on *BSD, then the
internal function _eina_file_map_populate() is used for the populate
rule. In that case actual data is read and we should make sure not to
trigger a segfault or bus error.
Also, this makes sure that in case of HugeTLB we actually populate all
pages, rather than one page out of 8 (we were jumping by 16Mb instead of
2Mb).
Note: Can we get the size of a HugeTLB at runtime? We're assuming 2Mb
which might very well not be the case!
See: https://wiki.debian.org/Hugepages
Tested by disabling MAP_POPULATE and observing crashes :)
@fix
This has been a long standing plan for improving performance in rendering
vector object. If your test involve updating gradient, you will get another
speedup of around 15%. Combined with previous shape, we get a 65% improvement
with doing the CPU intensive computation in there own thread before the
rendering kickoff. This was motly theorical until now, but well, it works
great !
This has been a long standing plan for improving performance in rendering
vector object. Depending on the test, you will get an improvement between
10 to 35% when rendering vector based object.
We are still maintaining the Cairo backend as the default one at the moment
due to a lack of result comparison tests between the two engine. Hopefully
we should get that covered and we can all enjoy a backend that is 4 times
faster by default.
Even though ownership info belongs to params/returns/etc at syntax
level, we can still store it in the type and turn several API funcs
into one this way.
This is the new ownership system for Eolian, working on params,
returns, struct fields or events directly rather than specifying
ownership at type level. As the new system will evolve it will
gain missing features and necessary checks.
for both ecore_exe_win32.c and ecore_exe_posix.c when the rare case
(basically almost never) that malloc fails for the exe read/err
buffers also set the data size to 0 so it doesn't lie with a NULL ptr
for data.
@fix
this has affected edje for... like... ever. min size of boxes just
doesnt work. because evas box just doesnt do it right. this has led to
nasty things where edje box is just not usable if you use weight of 0.
btw weight 0 means "stay at min size no matter what even if we expand
the box to be bigger" in edje... which is totally broken and i can't
fix that without potentially breaking even more stuff... but let's
see. i've been using this for several days now and ... i can't find
breakage... so this should fix up SOME issues in edje.
@fix
For example, aliases to ownable types are now also ownable,
which wasn't possible in the previous version, where you could
only own actual expanded ownable types.
device adds can happen late, which means evas does not know the default
device until a time that is later than the focusing of some edje part.
Which means that keystrokes etc. are lost for the parts beeing focused
before the default device appeared. This should fix that.
For the later people in this world: Watch out! someone decided to map
seats in edje with a linear counter starting at 1, which means
seat0<->seat1 seat1<->seat2 thanks for that riddle, i feel like i have
beaten the sphinxs.
fix T6022
We could just pass Efl_Time value as copy by value to set time in setter APIs
and return Efl_Time value in getter APIs.
Thanks to @JackDanielZ for the report.
Fixes T6008
This API was introduced in commit:
cd3f8db506
This was since limited to EO only APIs, and totally underexploited.
After that, efl_part() was introduced, which defines how all part APIs
should be designed.
Nothing uses this API, efl_vg had an implementation that provides no
extra value over the other APIs.
In Edje and Elementary, we have part objects, which are what is returned
by the interface efl_part(). Those objects can't be of an opaque type as
this doesn't work nicely with strongly typed languages such as C++ or
C#. In JS, Lua, C the types are weak and mostly runtime-based so it
doesn't matter much.
As a consequence, the documentation and the types need to look nice in
this EO API. Thus, we remove the abusive term "internal" and explicitly
call all those classes "part" something.
Eventually we want the types to be declared in the EO file so bindings
(C#, C++, ...) can generate the proper access methods, returning the
best possible types.
Note that right now a few of those part types are used in the legacy API
but don't actually need to be exposed externally.
This is kind of a mega commit that does all the renaming at once, but
it's really just a big sed operation. The power of good IDEs :)
Ref T5315
Ref T5306
This changes the CRI logs and the variable names.
I still think this API needs some fixing in order to not abuse the
smart object API. This should be done before it's too late (i.e. E is
released and depends on it).
This is a new function that indicates whether an object is a child of a
parent or not. Dead simple, as this simply compares if parent == this.
Note that this check was impossible to do with the event grabber.
Also, rename group_children_iterate to group_members_iterate for
consistency with the other group_member functions.
@feature
Inside emotion, if Eio is compiled, some asynchronous functions are used
and a refcounted struct was used to ensure safety of the code.
Unfortunately the logic didn't make much sense as emotion's private data
is used. The refcount becomes useless, the lifecycle of the data being
bound to the object itself.
Note that an actual crash is almost impossible because:
- eio is actually quite fast
- evas objects are kept alive for 2 frames
- eina_freeq is used to keep eo objects' data alive for some more time
But this in theory fixes the events, as they were sent on the wrong
object. "obj" is the image object, "smartobj" was the emotion object.
This is fixed with a weak ref.
I don't think it is necessary to backport this.
It's not exposing anything that wasn't already accessible before (you
could just add a member and get its clip, for instance).
This will be used by Edje Object.
This is a minor
@feature
- color_set
- visible_set
- position_set
- no_render_set
- member_add, member_del
- group_add, group_del
- clip_set
Notes:
- Widget overrides color_set without calling super() which means that
color_get() returns a different value. Also any subsequent child
object add will not inherit the color.
- Smart clipped objects also don't call super.
This patch changes that, but only for smart clipped objects created
through EO. This shouldn't have any side effect.
Jean-Philippe Andre
Sungtaek Hong
Lukasz Stanislawski
Daniel Hirt
Carsten Haitzler
Daniel Zaoui
Youngbok Shin
Felipe Magno de Almeida
Cedric BAIL
Jeeyong Um
Marcel Hollerbach
Daniel Kolesa
Mike Blumenkrantz
Vincent Torri
Andy Williams
Chris Michael
Hosang Kim
Jeonghyun Yun
jiin.moon
Bryce Harrington
Amitesh Singh
Jean Guyomarc'h
SangHyeon Jade Lee
InHong Han