This will be used to solve issues around style_set:
if the widget is legacy or pure eo we may need to select a different
style. So in the constructor we need to know whether we are legacy or
eo. Note that calling style_set in finalize only is too late as we would
lose information such as efl_text_set() called inside efl_add().
This region has little to do with focus, as it's more of a region of
interest within the widget, and not directly related to the highlight
geometry, for instance. It's related to focus in the sense that only
widgets with focus would really care about this region.
I decided to change this name after talking with @bu5hm4n.
Note that gengrid uses this but is also completely broken (the focus
highlight floats around and you don't even see the focused item).
Note: This is very close to show_region but I'm not sure those can be
merged safely (since the default "focus_region" is NULL while the
default "show_region" is the widget's geometry).
Ref T5363
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.
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
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
since sd->bx is not an elm object, it is excluded from parent-child tree.
in case of a non-scrollable panel, the content needs to be attached to the tree
as a child of panel object directly.
It's not beta. It's about to die.
Also, move #define ELM_WIDGET_BETA to the common header file, as it is
consequently required by ALL widgets. :(
Ping @bu5hm4n :)
Ref T5363
This is also another protected and beta API. Meant to be overridden by
subclasses, but belongs to a still unstable API.
The difference between the internal legacy and the EO API is really bad.
Same as with activate (previous commit).
Ref T5363
Renamed to on_disabled_update.
Also passed in the new state of disabled. It's more convenient this way,
than having the subclasses call disabled_get.
Also simplify some code...
Ref T5363
This factorizes the code and makes most widgets handle key down events
in the same way:
- check that the object is not disabled, event is not on hold
- figure out the key binding based on the class name
- mark event as on hold
The class name is usually MY_CLASS_NAME but in some cases it was
MY_CLASS_NAME_LEGACY which may be different from the EO class name (eg.
elm_win vs. Efl.Ui.Win). In that case the key bindings are broken.
This breaks key bindings for the following widgets:
- Win (focus)
- Image ("clicked")
- Video (move, play)
This fixes key bindings for the following widgets:
- Nstate
Some widgets remain broken:
- Photocam / Efl.Ui.Image.Zoomable
A patch will be applied to restore the key bindings for the above
breaks.
This is an internal function that should probably become an overridable
protected method, as it's required for proper event handling in widgets.
Next step: use eo_event_info in the widgets implementations. Then remove
legacy event struct.
Ref T5363
This removes an argument that was false only for a single widget:
naviframe. Hopefully this logic is now simpler, even though it involves
a small hack within naviframe itself.
Ref T5363
_elm_panel_efl_gfx_size_set() ends up calling
_elm_panel_elm_layout_sizing_eval() to adjust the layout
according to the updated width and height.
however, evas_object_geometr_get() doesn't return the updated values.
in fact, it is not necessary to call any API since the values are
stored as widget data in _elm_widget_efl_gfx_size_set().
elm_layout_sizing_eval() marks an object as requiring recalc.
Unfortunately, it's been massively abused by various widgets into
actually doing the calc, or the min calc. So we end up with one API
that has 3 different definitions depending on the widget type:
1. Mark as requiring recalc (correct, respects doc, elm_layout)
2. Calculate min size and other size hints
3. Actually do some geometry modification
I believe we need to clarify these 3 requirements into 3 very clear
and specific APIs in elementary. Right now we have similar functions
in evas for 1 (evas_object_smart_changed) and 3 (smart_calculate).
But their exact definition also isn't necessarily what we want for
elementary.
Another clear problem is that layout_eval does not do any calculation
(in theory), so the "eval" word is a bit of a stretch here.
Once we're sure about the exact API we want, we can add this back to
EO and make it work across our EO widgets. For now let's just keep
the legacy API, and its EO overrides, as is.
Ref T5315
Summary:
- elm_panel has a property named hidden which stores
open/close status.
- This is updated when:
1. bring_in animation is done(anim_stop_cb).
2. mouse_up on panel.
3. API is called. (elm_panel_toggle, elm_panel_hidden_set)
- In case 3, API changes hidden, and starts bring_in animation
which will call anim_stop_cb() which will update hidden again.
- If bring_in animation is canceled (eg: sizing_eval),
anim_stop_cb will be called and calculate hidden status
which will not guarantee updated hidden state by APIs.
Test Plan:
1. Call any APIs which will call elm_layout_sizing_eval(panel)
right after calling elm_panel_toggle()/elm_panel_hidden_set().
2. Delete content of panel during "toggled" cb.
Reviewers: jpeg, eunue, cedric
Subscribers: conr2d, cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4704
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
Summary:
- When scrollable panel is closed by elm_panel_hidden_set(),
elm_panel_toggle() APIs, it shows animation with
scroller bringin effect.
- During this animation, panel is still focusable, and may
stop closing when content gets focused.
- scrollable panel is now set unfocusable when closed by
APIs above, and set focusable when opened after bringin
animation.
Test Plan:
1) Set panel scrollable and opened.
2) Set another object focused and deleted it
when panel is closing.
3) Observe panel is closed.
Reviewers: cedric, jpeg, woohyun
Subscribers: conr2d, cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4641
Signed-off-by: Cedric BAIL <cedric@osg.samsung.com>
Summary:
Added get function for getting the size of the scrollable panel.
Additionally, added some exception handling code in scrollable_content_size_set
Reviewers: woohyun, eunue
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4549
Summary:
Elm.Widget.event_callback_add conflicts with Efl.Object.event_callback_add.
To solve this problem, "widget_" prefix is added to methods starting with
"event".
Reviewers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4521
in _state_sync() function, scrollable content's position is used to tell
whether the panel is open or not. in case of a top panel, for example,
it is considered to be open when the content's vertical position equals to zero.
however, this logic has a defect in that the position is always zero
if the content size is zero - not resized properly yet. it caused unwanted results.
this patch added some codes to check
1. if the panel's width or height is bigger than zero
2. if the box which contains panel contents is visible (resizable)
@fix
Summary:
The panel is freezed by elm_interface_scrollable_movement_block_set(),
but elm_interface_scrollable_freeze_set() is used to unfreeze panel.
Test Plan: elementar_test -> panel scrollable
Reviewers: woohyun, seoz, Hermet, cedric, raster
Subscribers: jpeg
Differential Revision: https://phab.enlightenment.org/D4458
This is an override of efl_gfx_size_set. Same as before, the
order of operations matter so it is possible that a corner
case will break. In particular, legacy code was:
- intercept
- smart resize (do stuff), super, super, super
- evas object resize
The new code is more like:
- intercept
- super, super, super, evas object resize
- do stuff
But unfortunately this broke elm_widget (read: all widgets) as
the internal resize was done before the object resize. So,
inside the resize event cb, the resize_obj size would not match
the smart object size. >_<
This is an override of efl_gfx_position_set.
As for the other patches, I hope I didn't break anything.
A problem likely to happen is that the super call was inserted
too early or too late in the call flow. For instance:
_myclass_position_set(obj, x, y) {
position_set(super(obj), x, y);
position_get(obj, &prevx, &prevy);
do_something_with_delta_xy();
}
The above code flow is obvisouly wrong, but may have crept in this
patch (such a bug sneaked in inside smart object, breaking
everything at first).
Summary:
1. Fix wrong logic of ELM_PANEL_ORIENT_RIGHT case in _state_sync.
2. Move pre calc function in anim_cb to sizing_eval function.
This code have caused problem that scrollable panel is not animated during drawer open and close.
3. Maintain content size ratio when orient is changed.
4. Freeze scroller when orient is changed.
This code will need to change orientation when drawer opened.
Reviewers: cedric, eunue
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4320
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.
Summary:
There are 2 ways to toogle the panel, by using elm_panel_toggle API and by interaction such as flick or click on panel.
This toggled event can help us to know the time when the panel toggled by all case.
Reviewers: woohyun, kimcinoo, Hermet, jypark
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4180
Summary:
if trying to apply incorrect theme, widget apply default theme and return TRUE.
so there is no way to check it really apply correct theme.
To resolve this problem, _elm_theme_set return three type enum
* related history : 4ca3ef4514
* elm_object_style_set is public api, so I didn't change it.
* typedef name [ Theme_Apply ] is temporarily, please suggest better one.
@fix
Reviewers: singh.amitesh, herb, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4073
Jean-Philippe Andre
Lukasz Stanislawski
Marcel Hollerbach
Jaeun Choi
Cedric Bail
Sungtaek Hong
JEONGHYUN YUN
Jee-Yong Um
Hosang Kim
Tom Hacohen
Vitor Sousa
Jinyong Park