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.
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.
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
Introduction to the problem:
- Efl.Canvas.Group has a method member_add() to add sub objects.
- Efl.Canvas.Group (simple smart object) does NOT actually delete the
objects on deletion. But:
- Efl.Canvas.Group.Clipped is a direct subclass and WILL delete the sub
objects on deletion.
Semantically, all smart objects (at least in EO and Elementary) will own
and delete sub objects automatically. Some exceptions are:
- Edje object (smart clipped) does not delete swallowed objects.
Edje object is a "clipped" smart object but it pops out all swallowed
children before getting deleted.
- Evas box/table/grid also pop out their children before deletion.
Those classes are all legacy & internal only.
- Elm.Widget will "manually" delete all its sub objects at deletion, as
it inherits from Efl.Canvas.Group but basically takes full ownership
of the sub objects. Note that member_add shouldn't be used on a
widget, the widgets do it themselves.
Also, smart clipped objects are much more convenient to use as they will
handle some things for you: color, visibility, moving and ownership.
So, the API member_add needs to be marked as own(). But right now
Efl.Canvas.Group does not own. Thus, here's the plan:
- Mark clipped objects as such with an internal API
- Merge clipped smart object features directly inside the standard
smart object.
- Get rid of Efl.Canvas.Group.Clipped entirely and watch all hell break
loose.
Ref T5301
We had here a little problem, state focus_state_eval function handled
the unregisteration and consideration of the focus flags and then only
called a helper function (which was a widget function), that then did
the registeration in logical or regular mode.
Elm scroller for example took that function overwrote it and did onyl
permit logical registrations. Then again a evaluation of the focus state
and flags took place, and the function considered elm_scroller should be
registered as regular object, but found it to be logical. This lead to
the problem that we permantently unregistered Elm.Scroller and
registered it again as logical just to unregister it again. This was on
the one side a performance downside. But also a bug since all items from
within the Elm_Scrollers sub manager are getting reparent onto the
parent, which means not the root of the scroller (the scroller itself)
is the logical entrypoint to the widget but rather this reparented
widget, which led to unexpected focus warps like described in T5923.
tldr: this fixes T5923
See the previous commits. All focus_highlight APIs are defined in the
Widget class but only implemented at the Window level. For consistency I
believe this call should also be forwarded to the window. The previous
logic had absolutely no effect at all, except storing a stringshare.
The day focus_highlight becomes widget-specific (i.e. each widget has
its own highlight style) then this can be changed.
Note: This will apply to legacy API as well.
Ref T5363
This removes the special code in the legacy API for
elm_widget_focus_mouse_up_handle. Add an internal helper to find the
first widget parent. And mark as protected.
Apparently this functions is still required for the new focus manager.
Ref T5363
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 a protected function. It doesn't need to return anything, as all
implementation just returned true, always. Also, the legacy API was just
a wrapper doing nothing special (except verify that we have a widget,
which the recursive code already does).
Tested with fr_FR :)
Ref T5363
It should be implemented as a efl_part() API.
For now I've only done a quick hack, as the only overrides were:
- notify: already a Part implementation. Also it turns out the default
theme does not even have any text part in the notify group.
- combobox: not a Part implementation, but also very badly defined wrt.
parts in general. efl_part() is handled by the parent class (button)
which makes it tricky to override just for one function.
With this patch I'm trying to keep the same behaviour as earlier (where
efl_part() is used for layouts and there is a special path for
combobox).
Ref T5363
I was told that the scrollable interface is being redesigned for EO.
This API definitely does not belong to the base Widget class, as it's
quite specific to item-based scrollable widgets, such as lists and
grids. Since Elm.Interface_Scrollable is itself being revamped, it is a
good place to move that EO API for now.
Ref T5363
1. Uniformize the API, which is now for internal use:
This uses the same enum as scroller "movement_block" instead
of 2 separate properties. Less APIs, more consistence.
2. Remove scroll_lock x/y from EO widget. I was told it is not going to
exist in the upcoming scrollable interface.
3. Remove scroll hold/freeze getters.
scroll hold/freeze push/pop are still there but it remains to be seen
how the EO scrollable interface will exploit them. Right now they are
full of bugs.
Ref T5363
This also includes the drag_child_lock APIs. This had nothing to do with
dragging beyond maybe the case where scrolling is done by thumbscroll
(ie. finger drag).
Note that the EAPI were called already scroll_lock, not drag_lock.
Ref T5363
This function is meant to be used by the widgets themselves, or internal
features such as elm_access.
Also remove const tag: this function call is definitely modifying the
widget (panning around and all that).
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
Renamed to on_orientation_update
This internal / virtual function is in fact not overridden anywhere. Not
sure it is necessary to expose it in EO API?
Ref T5363
Also prefix with widget.
I want to rename this as child rather than sub. It's inconsistent with
the other parent/child hierarchies. Anyway the various hierarchies are
confusing, so let's keep this name :)
Ref T5363
I'm not sure about the name for focus_allow:
- can_focus
- focusable
- focus_allow
- ???
Also, it looks like focus should just be the evas object function
overridden.
Ref T5363
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
it turns out to be very handy to have a interface for the moving and
border elements, that is unconnected to the way of how widgets are
registering themself.
This for example enables us to get a simple focus manager that just
redirects the call into a internal 2 dimensional data struct
This is only for EO obviously. style_set and theme_set should only be
called when the object is being created, not after. On-the-fly style
changes are complex to handle and in most cases it should be easy to
simply repopulate the object after creating a new one with a new style.
There are only a few cases where style_set is used long after creation
of an object, like changing how a label slides, or in the evas 3d map
examples. Menu seems to change the hover style a lot, so rewriting it in
pure EO would need some extra work, maybe.
Ref T5307
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_widget APIs are internal only, even if they may be EAPI. The EAPI
here is for modules.
I believe this API is only required for layout objects, so simply should
remain in the layout class. Then you can do efl_isa() and call the
functions or accept error messages if you want to be more careless.
Ref T5363
Some names have not been changed, hopefully making a distinction
between legacy APIs and internal code (elm_layout_blah) and valid EO
usages.
This means many internal functions are still elm_layout_ as their
sole purpose is to support the legacy API.
Ref T5315
This is really only a demonstration of what kind of information
we can print with efl_debug_name_get(). Hopefully this can help
debugging with printf/ERR logs and even help with live debugging
inside gdb.
This shouldn't be used for other purposes than debugging, as the
exact string format is not defined.
@feature
When destroying any object, its parent class destructor should
be called after the subclass destructor has been called. Only
some extremely limited work may be done after the super call.
This commit makes sure that all efl_destructor() overrides in
elementary are doing operations in the right order.
Also, remove a return void.
with this we can whipe out the focus.manager field in elm.widget so for
the case that something goes wrong we only get the error message where
actually something went wrong, and not the whole bunch of follow ups
where the code assumes its registered but it isnt.
it seems like the visibility is evalulated from different parent
relations, Just because the box (that is a container of a element) is
not visible, does not mean that the element in it is also not visible,
this somehow comes back to the box beeing deleted, the children beeing
reparented in evas, but not in elm. This is for now just a quickfix,
since those calls are just for optimization.
This fixes a load of errors once the elm_test window is closed
@fix
This will help to focus on creating efl_ui_widget class work.
And, we need to change all the Elm_Widget_Item related logics to
factory or something else.
This is a follow-up to a4b79fdbe1.
efl_part no longer supports NULL parts.
NULL text parts are now aliased in legacy code beforehand.
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
This affects the legacy content_set/get/unset part APIs. This
should avoid some unwanted ERR messages in case an elm_object_
API is used on an elm widget that doesn't implement said API.
What this does is request the widget for the name of the default
part if NULL was passed in. Since some widgets are not elm_layout,
they have to override the API themselves, which is why I made it
an internal EO API (rather than a series of efl_isa()).
In theory, part should never be NULL when reaching the internal
implementation code in the widgets, at least for content.
In EO, efl_part(obj, NULL) should be invalid.
Ref T5629
If content_part_{set,get,unset} are called on a widget that
is not a layout (or flip, and a few others), then some ERR
messages would be printed out.
We hide these ERR messages as all elm_object APIs should be
callable on an object for which elm_object_widget_check()
returns true.
Ref T5629
This is, unlike what some of the documentation says, a public
API on elm_object. Let's place it along mirrored for consistency,
even if edje object will not implement it.
Ref T5363
It was always returning true. There is little point in returning
a bool here, an invalid scale value (eg. <= 0) wouuld lead to a
state where scale_get() != scale_set() and that's about it.
This size hint is only used by naviframe, which is not part of
our EO widgets. I also believe it might be an even more confusing
hint than the others.
I kept the typedef as is in Evas_Legacy.h in case an app is
written using EFL_GFX_ instead of EVAS_...