EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, ppd);
EFL_UI_ANCHOR_POPUP_DATA_GET(obj, pd);
+ if (!pd->anchor) return;
+
Eina_Position2D pos = {0, 0};
Eina_Rect a_geom = efl_gfx_entity_geometry_get(pd->anchor);
efl_event_callback_del(ppd->win_parent, EFL_GFX_ENTITY_EVENT_SIZE_CHANGED, _anchor_geom_cb, data);
pd->anchor = NULL;
- //Add align calc only
- Eina_Bool needs_size_calc = ppd->needs_size_calc;
- efl_canvas_group_change(data);
- efl_canvas_group_calculate(data);
- ppd->needs_size_calc = needs_size_calc;
+ _anchor_calc(data);
}
static void
efl_event_callback_add(anchor, EFL_EVENT_DEL, _anchor_del_cb, obj);
}
- //Add align/anchor calc only
- Eina_Bool needs_size_calc = ppd->needs_size_calc;
- efl_canvas_group_change(obj);
- efl_canvas_group_calculate(obj);
- ppd->needs_size_calc = needs_size_calc;
+ _anchor_calc(obj);
}
EOLIAN static Efl_Object *
}
EOLIAN static void
-_efl_ui_anchor_popup_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Anchor_Popup_Data *pd)
+_efl_ui_anchor_popup_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Anchor_Popup_Data *pd EINA_UNUSED)
{
- EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, ppd);
- /* When efl_canvas_group_change() is called, just flag is set instead of size
- * calculation.
- * The actual size calculation is done here when the object is rendered to
- * avoid duplicate size calculations. */
- if (ppd->needs_group_calc)
- {
- if (pd->anchor)
- ppd->needs_align_calc = EINA_FALSE;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
- efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
- if (pd->anchor)
- _anchor_calc(obj);
- }
+ _anchor_calc(obj);
}
EOLIAN static Eo *
EOLIAN static void
_efl_ui_box_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Box_Data *_pd EINA_UNUSED)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
efl_pack_layout_update(obj);
}
}
}
-EOLIAN static void
-_efl_ui_button_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Button_Data *_pd EINA_UNUSED)
-{
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
- Evas_Coord minw = -1, minh = -1;
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
-}
-
EOLIAN static Eina_Bool
_efl_ui_button_efl_ui_widget_on_access_activate(Eo *obj, Efl_Ui_Button_Data *_pd EINA_UNUSED, Efl_Ui_Activate act)
{
#define EFL_UI_BUTTON_EXTRA_OPS \
ELM_LAYOUT_CONTENT_ALIASES_OPS(MY_CLASS_PFX), \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_button), \
EFL_CANVAS_GROUP_ADD_OPS(efl_ui_button)
#include "efl_ui_button.eo.c"
static Eina_Bool _efl_ui_calendar_smart_focus_next_enable = EINA_FALSE;
-EOLIAN static void
-_efl_ui_calendar_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Calendar_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- EFL_UI_CALENDAR_DATA_GET(obj, sd);
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- if (sd->filling) return;
- // 7x8 (1 month+year, days, 6 dates.)
- elm_coords_finger_size_adjust(7, &minw, 8, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
// Get the max day number for each month
static inline int
_maxdays_get(struct tm *date, int month_offset)
EOLIAN static void
_efl_ui_calendar_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Calendar_Data *_pd EINA_UNUSED)
{
- elm_layout_freeze(obj);
-
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
_set_headers(obj);
_populate(obj);
- elm_layout_thaw(obj);
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
EOLIAN static void
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_DATE_EDITOR);
obj = _efl_ui_calendar_constructor_internal(obj, sd);
+ // 7x8 (1 month+year, days, 6 dates.)
+ efl_ui_layout_finger_size_multiplier_set(obj, 7, 8);
return obj;
}
ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(efl_ui_calendar, Efl_Ui_Calendar_Data)
-/* Internal EO APIs and hidden overrides */
-
-#define EFL_UI_CALENDAR_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_calendar)
-
#include "efl_ui_calendar.eo.c"
typedef struct {
return EINA_TRUE;
}
-EOLIAN static void
-_efl_ui_check_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Check_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
static Eina_Bool
_key_action_activate(Evas_Object *obj, const char *params EINA_UNUSED)
{
#define EFL_UI_CHECK_EXTRA_OPS \
ELM_LAYOUT_CONTENT_ALIASES_OPS(MY_CLASS_PFX), \
- ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_check)
+ ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX)
#include "efl_ui_check.eo.c"
if (field->fmt_exist && field->visible)
sd->enabled_field_count++;
}
+ efl_ui_layout_finger_size_multiplier_set(obj, sd->enabled_field_count, 1);
// assign locations to disabled fields for uniform usage
for (idx = 0; idx < EFL_UI_CLOCK_TYPE_COUNT; idx++)
}
EOLIAN static void
-_efl_ui_clock_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Clock_Data *sd)
+_efl_ui_clock_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Clock_Data *sd)
{
- Evas_Coord minw = -1, minh = -1;
-
- if (sd->freeze_sizing) return;
-
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- if (sd->enabled_field_count)
- elm_coords_finger_size_adjust(sd->enabled_field_count, &minw, 1, &minh);
-
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
+ /* FIXME: this seems dumb */
+ if (!sd->freeze_sizing)
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
EOLIAN static Eina_Error
evas_object_hide(elm_layout_content_unset(obj, buf));
}
sd->freeze_sizing = EINA_FALSE;
+ efl_ui_layout_finger_size_multiplier_set(obj, sd->enabled_field_count, 1);
efl_canvas_group_change(obj);
/* Internal EO APIs and hidden overrides */
#define EFL_UI_CLOCK_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_clock), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_clock)
#include "efl_ui_clock.eo.c"
}
implements {
Efl.Object.constructor;
+ Efl.Canvas.Group.group_calculate;
Efl.Ui.Widget.theme_apply;
Efl.Ui.Focus.Object.on_focus_update;
Efl.Ui.L10n.translation_update;
}
}
-EOLIAN static void
-_efl_ui_datepicker_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Datepicker_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
EOLIAN static Eo *
_efl_ui_datepicker_efl_object_constructor(Eo *obj, Efl_Ui_Datepicker_Data *pd)
{
*day = pd->cur_date[DATEPICKER_DAY];
}
-#define EFL_UI_DATEPICKER_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_datepicker), \
-
#include "efl_ui_datepicker.eo.c"
EOLIAN static void
_efl_ui_frame_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Frame_Data *sd)
{
- EFL_UI_LAYOUT_DATA_GET(obj, ld);
-
- if (ld->needs_size_calc)
- {
- /* calling OWN sizing evaluate code here */
- _sizing_eval(obj, sd);
- ld->needs_size_calc = EINA_FALSE;
- }
+ /* calling OWN sizing evaluate code here */
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
+ _sizing_eval(obj, sd);
}
static void
Eina_List *l;
Evas_Coord ox, oy, ow, oh;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
ELM_WIDGET_DATA_GET_OR_RETURN(psd->wobj, wd);
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
}
EOLIAN static void
-_efl_ui_internal_text_scroller_elm_layout_sizing_eval(Eo *obj,
+_efl_ui_internal_text_scroller_efl_canvas_group_group_calculate(Eo *obj,
Efl_Ui_Internal_Text_Scroller_Data *sd)
{
Eina_Size2D size = {-1, -1};
Eina_Rect view = EINA_RECT(0, 0, 0, 0);
Evas_Coord vmw = 0, vmh = 0;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
EFL_UI_SCROLLER_DATA_GET(obj, psd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
/* Internal EO APIs and hidden overrides */
-#define EFL_UI_INTERNAL_TEXT_SCROLLER_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_internal_text_scroller)
-
#include "efl_ui_internal_text_scroller.eo.c"
Efl.Object.constructor;
Efl.Object.finalize;
Efl.Object.destructor;
+ Efl.Canvas.Group.group_calculate;
}
}
/* Mouse Controls ends */
-static void
-_sizing_eval(Evas_Object *obj, Efl_Ui_Item_Data *pd)
-{
- Evas_Coord minh = -1, minw = -1;
- Evas_Coord rest_w = 0, rest_h = 0;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- edje_object_size_min_restricted_calc(wd->resize_obj, &minw, &minh,
- rest_w, rest_h);
- evas_object_size_hint_min_set(obj, minw, minh);
-
- pd->needs_size_calc = EINA_FALSE;
-}
-
-static void
-_efl_ui_item_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Item_Data *pd)
-{
- if (pd->needs_size_calc) return;
- pd->needs_size_calc = EINA_TRUE;
-
- efl_canvas_group_change(obj);
-}
-
-EOLIAN static void
-_efl_ui_item_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Item_Data *pd)
-{
- if (pd->needs_size_calc)
- {
- _sizing_eval(obj, pd);
- pd->needs_size_calc = EINA_FALSE;
- }
-}
-
EOLIAN static Eo *
_efl_ui_item_efl_object_constructor(Eo *obj, Efl_Ui_Item_Data *pd EINA_UNUSED)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
efl_event_callback_array_add(obj, self_listening(), obj);
return pd->parent;
}
-/* Internal EO APIs and hidden overrides */
-
-#define EFL_UI_ITEM_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_item)
-
#include "efl_ui_item.eo.c"
Efl.Object.constructor;
Efl.Object.finalize;
Efl.Object.destructor;
- Efl.Canvas.Group.group_calculate;
}
}
if (!efl_alive_get(obj)) return;
+ if (sd->calc_subobjs && !evas_smart_objects_calculating_get(evas_object_evas_get(obj)))
+ {
+ Eina_List *l;
+ Eo *subobj;
+ /* user has manually triggered a smart calc and wants subobjs to also calc */
+ EINA_LIST_FOREACH(wd->subobjs, l, subobj)
+ efl_canvas_group_calculate(subobj);
+ }
elm_coords_finger_size_adjust(sd->finger_size_multiplier_x, &rest_w,
sd->finger_size_multiplier_y, &rest_h);
if (elm_widget_is_legacy(obj))
elm_coords_finger_size_adjust(sd->finger_size_multiplier_x, NULL,
sd->finger_size_multiplier_y, &minh);
evas_object_size_hint_min_set(obj, minw, minh);
-
+ efl_gfx_hint_size_restricted_min_set(obj, EINA_SIZE2D(minw, minh));
sd->restricted_calc_w = sd->restricted_calc_h = EINA_FALSE;
}
+void
+_efl_ui_layout_subobjs_calc_set(Eo *obj, Eina_Bool set)
+{
+ Efl_Ui_Layout_Data *sd = efl_data_scope_safe_get(obj, MY_CLASS);
+ EINA_SAFETY_ON_NULL_RETURN(sd);
+ sd->calc_subobjs = !!set;
+}
+
/* common content cases for layout objects: icon and text */
static inline void
_signals_emit(Eo *obj,
(theme_apply_internal_ret == EFL_UI_THEME_APPLY_ERROR_DEFAULT))
return EFL_UI_THEME_APPLY_ERROR_DEFAULT;
+ /* unset existing size hints to force accurate recalc */
+ efl_gfx_hint_size_restricted_min_set(obj, EINA_SIZE2D(0, 0));
+ if (elm_widget_is_legacy(obj))
+ efl_gfx_hint_size_min_set(obj, EINA_SIZE2D(0, 0));
+
return EFL_UI_THEME_APPLY_ERROR_NONE;
}
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
eo = efl_finalize(efl_super(obj, MY_CLASS));
efl_ui_widget_theme_apply(eo);
+ efl_canvas_group_change(obj);
win = elm_widget_top_get(obj);
if (efl_isa(win, EFL_UI_WIN_CLASS))
EOLIAN static void
_efl_ui_list_view_pan_efl_canvas_group_group_calculate(Eo *obj EINA_UNUSED, Efl_Ui_List_View_Pan_Data *psd)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
evas_object_smart_changed(psd->wobj);
}
EOLIAN static void
_efl_ui_pan_efl_canvas_group_group_calculate(Eo *obj EINA_UNUSED, Efl_Ui_Pan_Data *psd)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
efl_gfx_entity_position_set(psd->content, EINA_POSITION2D(psd->x - psd->px, psd->y - psd->py));
}
#include "efl_ui_pan.eo.c"
}
EOLIAN static void
-_efl_ui_panel_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Panel_Data *sd)
+_efl_ui_panel_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Panel_Data *sd)
{
- Evas_Coord mw = 0, mh = 0;
-
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (sd->delete_me) return;
else _drawer_open(obj, wd->w, wd->h, EINA_FALSE);
}
- evas_object_smart_calculate(sd->bx);
- edje_object_size_min_calc(wd->resize_obj, &mw, &mh);
- evas_object_size_hint_min_set(obj, mw, mh);
- evas_object_size_hint_max_set(obj, -1, -1);
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
static char *
else
{
elm_layout_content_set(obj, "efl.content", _pd->bx);
+ /* trigger box recalc on manual panel calc */
+ _efl_ui_layout_subobjs_calc_set(obj, EINA_TRUE);
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
if (edje_object_part_exists
(wd->resize_obj, "efl.swallow.event"))
/* Internal EO APIs and hidden overrides */
-#define EFL_UI_PANEL_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_panel)
-
#include "efl_ui_panel.eo.c"
Efl.Gfx.Entity.position { set; }
Efl.Gfx.Entity.size { set; }
Efl.Canvas.Group.group_member_add;
+ Efl.Canvas.Group.group_calculate;
Efl.Ui.Widget.theme_apply;
Efl.Ui.Widget.disabled {set;}
Efl.Ui.Widget.on_access_update;
}
EOLIAN static void
-_efl_ui_panes_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Panes_Data *sd)
+_efl_ui_panes_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Panes_Data *sd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Eo *first_content, *second_content;
Eina_Size2D min;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
if (elm_widget_is_legacy(obj))
{
first_content = efl_content_get(efl_part(obj, "elm.swallow.left"));
#define EFL_UI_PANES_EXTRA_OPS \
EFL_CANVAS_GROUP_ADD_OPS(efl_ui_panes), \
- ELM_LAYOUT_CONTENT_ALIASES_OPS(efl_ui_panes), \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_panes)
+ ELM_LAYOUT_CONTENT_ALIASES_OPS(efl_ui_panes)
#include "efl_ui_panes.eo.c"
#include "efl_ui_panes_eo.legacy.c"
}
implements {
Efl.Object.constructor;
+ Efl.Canvas.Group.group_calculate;
Efl.Ui.Widget.theme_apply;
Efl.Ui.Layout_Orientable.orientation { get; set; [[Only supports $vertical and $horizontal. Default is $vertical.]] }
Efl.Part.part_get;
EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, pd);
- //Add align calc only
- Eina_Bool needs_size_calc = pd->needs_size_calc;
efl_canvas_group_change(obj);
- efl_canvas_group_calculate(obj);
- pd->needs_size_calc = needs_size_calc;
}
EOLIAN static void
{
pd->align = type;
- //Add align calc only
- Eina_Bool needs_size_calc = pd->needs_size_calc;
efl_canvas_group_change(obj);
- efl_canvas_group_calculate(obj);
- pd->needs_size_calc = needs_size_calc;
}
EOLIAN static Efl_Ui_Popup_Align
static void
_sizing_eval(Eo *obj)
{
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
- Evas_Coord minw = -1, minh = -1;
+ Eina_Size2D min;
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- efl_gfx_hint_size_min_set(obj, EINA_SIZE2D(minw, minh));
+ /* trigger layout calc */
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
+ min = efl_gfx_hint_size_restricted_min_get(obj);
Eina_Size2D size = efl_gfx_entity_size_get(obj);
Eina_Size2D new_size;
- new_size.w = (minw > size.w ? minw : size.w);
- new_size.h = (minh > size.h ? minh : size.h);
+ new_size.w = (min.w > size.w ? min.w : size.w);
+ new_size.h = (min.h > size.h ? min.h : size.h);
efl_gfx_entity_size_set(obj, new_size);
-}
-
-EOLIAN static void
-_efl_ui_popup_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Popup_Data *pd)
-{
- if (pd->needs_group_calc) return;
- pd->needs_group_calc = EINA_TRUE;
-
- /* These flags can be modified by sub classes not to calculate size or align
- * their super classes.
- * e.g. Efl.Ui.Popup.Alert.Scroll class sets the flag as follows not to
- * calculate size by its super class.
- *
- * ppd->needs_size_calc = EINA_FALSE;
- * efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
- */
- pd->needs_size_calc = EINA_TRUE;
- pd->needs_align_calc = EINA_TRUE;
-
- evas_object_smart_changed(obj);
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
EOLIAN static void
* calculation.
* The actual size calculation is done here when the object is rendered to
* avoid duplicate size calculations. */
- if (pd->needs_group_calc)
- {
- if (pd->needs_size_calc)
- {
- _sizing_eval(obj);
- pd->needs_size_calc = EINA_FALSE;
- }
- if (pd->needs_align_calc)
- {
- _calc_align(obj);
- pd->needs_align_calc = EINA_FALSE;
- }
-
- Eina_Rect p_geom = efl_gfx_entity_geometry_get(pd->win_parent);
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
+ _sizing_eval(obj);
+ _calc_align(obj);
- efl_gfx_entity_position_set(pd->backwall, EINA_POSITION2D(0, 0));
- efl_gfx_entity_size_set(pd->backwall, EINA_SIZE2D(p_geom.w, p_geom.h));
+ Eina_Rect p_geom = efl_gfx_entity_geometry_get(pd->win_parent);
- pd->needs_group_calc = EINA_FALSE;
- }
+ efl_gfx_entity_position_set(pd->backwall, EINA_POSITION2D(0, 0));
+ efl_gfx_entity_size_set(pd->backwall, EINA_SIZE2D(p_geom.w, p_geom.h));
}
/* Standard widget overrides */
/* Efl.Part end */
-/* Internal EO APIs and hidden overrides */
-
-#define EFL_UI_POPUP_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_popup)
-
#include "efl_ui_popup.eo.c"
Efl_Ui_Popup_Align align;
Ecore_Timer *timer;
double timeout;
- Eina_Bool needs_group_calc : 1;
- Eina_Bool needs_size_calc : 1;
- Eina_Bool needs_align_calc : 1;
};
#define EFL_UI_POPUP_DATA_GET_OR_RETURN(o, ptr, ...) \
}
}
-EOLIAN static void
-_efl_ui_progressbar_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Progressbar_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
//TODO: efl_ui_slider also use this.
static const char *
_theme_group_modify_pos_get(const char *cur_group, const char *search, size_t len, Eina_Bool is_legacy)
elm_widget_theme_klass_set(obj, "progressbar");
efl_canvas_group_add(efl_super(obj, MY_CLASS));
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
+
priv->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
priv->val = MIN_RATIO_LVL;
priv->val_max = 1.0;
#define EFL_UI_PROGRESSBAR_EXTRA_OPS \
ELM_LAYOUT_CONTENT_ALIASES_OPS(efl_ui_progressbar), \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_progressbar), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_progressbar)
#include "efl_ui_progressbar.eo.c"
EOLIAN static void
_efl_ui_relative_layout_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Relative_Layout_Data *pd EINA_UNUSED)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
efl_pack_layout_update(obj);
}
elm_scroller_content_min_limit(pd->scroller, min_limit_w, min_limit_h);
efl_gfx_entity_size_set(obj, new_size);
}
+ efl_canvas_group_calculate(pd->scroller);
efl_gfx_hint_size_min_set(obj, new_min);
}
//Calculate popup's min size including scroller's min size
{
elm_scroller_content_min_limit(pd->scroller, EINA_TRUE, EINA_TRUE);
+ efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &scr_minw, 1, &scr_minh);
edje_object_size_min_restricted_calc
//Calculate popup's min size except scroller's min size
{
elm_scroller_content_min_limit(pd->scroller, EINA_FALSE, EINA_FALSE);
+ efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &obj_minw, 1, &obj_minh);
edje_object_size_min_restricted_calc
* calculation.
* The actual size calculation is done here when the object is rendered to
* avoid duplicate size calculations. */
- EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, ppd);
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
- if (ppd->needs_group_calc)
- {
- if (ppd->needs_size_calc)
- _sizing_eval(obj, pd);
+ _sizing_eval(obj, pd);
- //Not to calculate size by super class
- ppd->needs_size_calc = EINA_FALSE;
- efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
- }
+ //Not to calculate size by super class
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
static Eina_Bool
}
EOLIAN static void
-_efl_ui_scroller_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Scroller_Data *sd)
+_efl_ui_scroller_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Scroller_Data *sd)
{
Eina_Size2D min = {0, 0}, max = {0, 0}, size = {-1, -1};
Eina_Rect view = {};
Evas_Coord vmw = 0, vmh = 0;
double xw = 0.0, yw = 0.0;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (sd->content)
/* Internal EO APIs and hidden overrides */
-#define EFL_UI_SCROLLER_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_scroller)
-
#include "efl_ui_scroller.eo.c"
Efl.Object.destructor;
Efl.Content.content { get; set; }
Efl.Content.content_unset;
+ Efl.Canvas.Group.group_calculate;
Efl.Ui.Widget.theme_apply;
Efl.Ui.Widget.focus_state_apply;
Efl.Ui.Widget.widget_input_event_handler;
return int_ret;
}
-EOLIAN static void
-_efl_ui_slider_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Slider_Data *_pd EINA_UNUSED)
-{
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
- Evas_Coord minw = -1, minh = -1;
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- efl_gfx_hint_size_restricted_min_set(obj, EINA_SIZE2D(minw, minh));
- efl_gfx_hint_size_max_set(obj, EINA_SIZE2D(-1, -1));
-}
-
static void
_spacer_down_cb(void *data,
Evas *e EINA_UNUSED,
EFL_VOID_FUNC_BODYV(efl_ui_slider_move_knob, EFL_FUNC_CALL(button_x, button_y), double button_x, double button_y)
#define EFL_UI_SLIDER_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_slider), \
EFL_UI_SLIDER_VAL_FETCH_OPS(efl_ui_slider), \
EFL_UI_SLIDER_VAL_SET_OPS(efl_ui_slider), \
EFL_UI_SLIDER_DOWN_KNOB_OPS(efl_ui_slider), \
eina_strbuf_free(strbuf);
}
-EOLIAN static void
-_efl_ui_spin_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Spin_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
EOLIAN static Eina_Bool
_efl_ui_spin_efl_ui_widget_widget_input_event_handler(Eo *obj, Efl_Ui_Spin_Data *sd, const Efl_Event *eo_event, Evas_Object *src EINA_UNUSED)
{
return sd->val;
}
-#define EFL_UI_SPIN_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_spin), \
-
#include "efl_ui_spin.eo.c"
EOLIAN void
_efl_ui_table_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Table_Data *_pd EINA_UNUSED)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
efl_pack_layout_update(obj);
}
return EINA_FALSE;
}
-EOLIAN static void
-_efl_ui_tags_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Tags_Data *sd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
-
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- efl_gfx_hint_size_min_set(obj, EINA_SIZE2D(minw, minh));
- efl_gfx_hint_size_max_set(obj, EINA_SIZE2D(maxw, maxh));
-}
-
static void
_mouse_clicked_signal_cb(void *data EINA_UNUSED,
Evas_Object *obj,
_view_update(pd);
}
-#define EFL_UI_TAGS_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_tags), \
-
#include "efl_ui_tags.eo.c"
#define SIZE2D_EQ(X, Y) (((X).w == (Y).w) && ((X).h == (Y).h))
EOLIAN static void
-_efl_ui_text_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Text_Data *sd)
+_efl_ui_text_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Text_Data *sd)
{
Eina_Size2D min = EINA_SIZE2D(0, 0);
Eina_Size2D edmin = EINA_SIZE2D(0, 0);
Eina_Size2D sz = EINA_SIZE2D(0, 0);
+
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
sz = efl_gfx_entity_size_get(obj);
//ELM_LAYOUT_CONTENT_ALIASES_IMPLEMENT(MY_CLASS_PFX)
-#define EFL_UI_TEXT_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_text)
-
#include "efl_ui_text.eo.c"
EOLIAN static Eo *
Efl.Gfx.Entity.position { set; }
Efl.Gfx.Entity.size { set; }
Efl.Canvas.Group.group_member_add;
+ Efl.Canvas.Group.group_calculate;
Efl.Layout.Signal.signal_callback_add;
Efl.Layout.Signal.signal_callback_del;
Efl.Layout.Signal.signal_emit;
elm_scroller_content_min_limit(pd->scroller, min_limit_w, min_limit_h);
efl_gfx_entity_size_set(obj, new_size);
}
+ efl_canvas_group_calculate(pd->scroller);
efl_gfx_hint_size_min_set(obj, new_min);
}
//Calculate popup's min size including scroller's min size
{
elm_label_line_wrap_set(pd->message, ELM_WRAP_NONE);
+ efl_canvas_group_calculate(pd->message);
text_min = efl_gfx_hint_size_combined_min_get(pd->message);
elm_label_line_wrap_set(pd->message, ELM_WRAP_MIXED);
+ efl_canvas_group_calculate(pd->message);
elm_scroller_content_min_limit(pd->scroller, EINA_FALSE, EINA_TRUE);
+ efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &text_minw, 1, &text_minh);
edje_object_size_min_restricted_calc
//Calculate popup's min size except scroller's min size
{
elm_scroller_content_min_limit(pd->scroller, EINA_FALSE, EINA_FALSE);
+ efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &obj_minw, 1, &obj_minh);
edje_object_size_min_restricted_calc
* calculation.
* The actual size calculation is done here when the object is rendered to
* avoid duplicate size calculations. */
- EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, ppd);
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
- if (ppd->needs_group_calc)
- {
- if (ppd->needs_size_calc)
- _sizing_eval(obj, pd);
+ _sizing_eval(obj, pd);
- //Not to calculate size by super class
- ppd->needs_size_calc = EINA_FALSE;
- efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
- }
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
static Eina_Bool
}
EOLIAN static void
-_efl_ui_textpath_efl_canvas_group_group_calculate(Eo *obj EINA_UNUSED, Efl_Ui_Textpath_Data *pd)
+_efl_ui_textpath_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Textpath_Data *pd)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
_sizing_eval(pd);
}
}
}
-EOLIAN static void
-_efl_ui_timepicker_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Timepicker_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
EOLIAN static Eo *
_efl_ui_timepicker_efl_object_constructor(Eo *obj, Efl_Ui_Timepicker_Data *pd EINA_UNUSED)
{
return pd->is_24hour;
}
-#define EFL_UI_TIMEPICKER_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_timepicker), \
-
#include "efl_ui_timepicker.eo.c"
}
EOLIAN static void
-_efl_ui_video_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Video_Data *sd)
+_efl_ui_video_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Video_Data *sd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Evas_Coord minw = 0, minh = 0;
Evas_Coord w = 0, h = 0;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
evas_object_size_hint_request_get(sd->emotion, &minw, &minh);
if (minw && minh)
evas_object_size_hint_aspect_set
/* Internal EO APIs and hidden overrides */
#define EFL_UI_VIDEO_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_video), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_video)
#include "efl_ui_video.eo.c"
implements {
Efl.Object.constructor;
Efl.File.load;
+ Efl.Canvas.Group.group_calculate;
Efl.Ui.Widget.widget_input_event_handler;
Efl.Access.Widget.Action.elm_actions { get; }
Efl.Player.start;
_efl_ui_widget_efl_canvas_group_group_calculate(Eo *obj EINA_UNUSED, Elm_Widget_Smart_Data *_pd EINA_UNUSED)
{
/* a NO-OP, on the base */
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
}
EOLIAN static void
}
EOLIAN static void
-_elm_ctxpopup_elm_layout_sizing_eval(Eo *obj, Elm_Ctxpopup_Data *sd)
+_elm_ctxpopup_efl_canvas_group_calculate(Eo *obj, Elm_Ctxpopup_Data *sd)
{
Eina_Rectangle rect = { 0, 0, 1, 1 };
Evas_Coord_Point list_size = { 0, 0 }, parent_size = {0, 0};
/* Internal EO APIs and hidden overrides */
#define ELM_CTXPOPUP_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_ctxpopup), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_ctxpopup), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_ctxpopup)
#include "elm_ctxpopup_item_eo.c"
(data, ELM_FILESELECTOR_ENTRY_EVENT_ACTIVATED, event->info);
}
-EOLIAN static void
-_elm_fileselector_entry_elm_layout_sizing_eval(Eo *obj, Elm_Fileselector_Entry_Data *sd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
-
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- edje_object_size_min_calc(wd->resize_obj, &minw, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
EOLIAN static Eina_Error
_elm_fileselector_entry_efl_ui_widget_theme_apply(Eo *obj, Elm_Fileselector_Entry_Data *sd)
{
efl_ui_mirrored_set(priv->button, efl_ui_mirrored_get(obj));
elm_widget_style_set(priv->button, "fileselector_entry/default");
efl_composite_attach(obj, priv->button);
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
elm_fileselector_expandable_set
(priv->button, _elm_config->fileselector_expand_enable);
#define ELM_FILESELECTOR_ENTRY_EXTRA_OPS \
ELM_PART_CONTENT_DEFAULT_OPS(elm_fileselector_entry), \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_fileselector_entry), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_fileselector_entry)
#include "elm_fileselector_entry_eo.c"
return EINA_FALSE;
}
-EOLIAN static void
-_elm_multibuttonentry_elm_layout_sizing_eval(Eo *obj, Elm_Multibuttonentry_Data *sd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
-
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, maxw, maxh);
-}
-
static void
_mouse_clicked_signal_cb(void *data EINA_UNUSED,
Evas_Object *obj,
/* Internal EO APIs and hidden overrides */
#define ELM_MULTIBUTTONENTRY_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_multibuttonentry), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_multibuttonentry)
#include "elm_multibuttonentry_item_eo.c"
}
EOLIAN static void
-_elm_naviframe_elm_layout_sizing_eval(Eo *obj, Elm_Naviframe_Data *sd)
+_elm_naviframe_efl_canvas_group_calculate(Eo *obj, Elm_Naviframe_Data *sd)
{
Evas_Coord minw = 0, minh = 0;
Elm_Naviframe_Item_Data *it, *top;
/* Internal EO APIs and hidden overrides */
#define ELM_NAVIFRAME_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_naviframe), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_naviframe), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_naviframe)
#include "elm_naviframe_item_eo.c"
return int_ret;
}
-EOLIAN static void
-_elm_player_elm_layout_sizing_eval(Eo *obj, Elm_Player_Data *sd EINA_UNUSED)
-{
- Evas_Coord w, h;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- edje_object_size_min_get(wd->resize_obj, &w, &h);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &w, &h, w, h);
- evas_object_size_hint_min_set(obj, w, h);
-}
-
static void
_update_slider(void *data, const Efl_Event *event EINA_UNUSED)
{
if (!elm_layout_theme_set(obj, "player", "base", elm_widget_style_get(obj)))
CRI("Failed to set layout!");
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
priv->forward = _player_button_add(obj, "forward", _forward);
priv->info = _player_button_add(obj, "info", _info);
priv->next = _player_button_add(obj, "next", _next);
#define ELM_PLAYER_EXTRA_OPS \
ELM_PART_CONTENT_DEFAULT_OPS(elm_player), \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_player), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_player)
#include "elm_player_eo.c"
}
EOLIAN static void
-_elm_popup_elm_layout_sizing_eval(Eo *obj, Elm_Popup_Data *sd)
+_elm_popup_efl_canvas_group_calculate(Eo *obj, Elm_Popup_Data *sd)
{
Eina_List *elist;
Elm_Popup_Item_Data *it;
/* Internal EO APIs and hidden overrides */
#define ELM_POPUP_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_popup), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_popup), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_popup)
#include "elm_popup_eo.c"
return pos;
}
-EOLIAN static void
-_elm_actionslider_elm_layout_sizing_eval(Eo *obj, Elm_Actionslider_Data *sd)
-{
- Evas_Coord minw = -1, minh = -1;
-
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- evas_object_size_hint_min_set(sd->drag_button_base, minw, minh);
- evas_object_size_hint_max_set(sd->drag_button_base, -1, -1);
-
- minw = -1;
- minh = -1;
- elm_coords_finger_size_adjust(3, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
static void
_mirroredness_change_eval(Evas_Object *obj)
{
EOLIAN static void
_elm_actionslider_efl_canvas_group_group_add(Eo *obj, Elm_Actionslider_Data *priv)
{
+ Evas_Coord minw = -1, minh = -1;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
efl_canvas_group_add(efl_super(obj, MY_CLASS));
priv->enabled_position = ELM_ACTIONSLIDER_ALL;
+ efl_ui_layout_finger_size_multiplier_set(obj, 3, 1);
+
priv->drag_button_base =
evas_object_rectangle_add(evas_object_evas_get(obj));
+ elm_coords_finger_size_adjust(1, &minw, 1, &minh);
+ evas_object_size_hint_min_set(priv->drag_button_base, minw, minh);
evas_object_color_set(priv->drag_button_base, 0, 0, 0, 0);
// dirty support for the backward compatibility
#define ELM_ACTIONSLIDER_EXTRA_OPS \
ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_actionslider), \
EFL_CANVAS_GROUP_ADD_OPS(elm_actionslider)
#include "elm_actionslider_eo.c"
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
elm_box_recalculate(obj);
}
"bottom_right"
};
-EOLIAN static void
-_elm_bubble_elm_layout_sizing_eval(Eo *obj, Elm_Bubble_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
static void
_on_mouse_up(void *data,
Evas *e EINA_UNUSED,
#define ELM_BUBBLE_EXTRA_OPS \
ELM_LAYOUT_CONTENT_ALIASES_OPS(MY_CLASS_PFX), \
ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_bubble), \
EFL_CANVAS_GROUP_ADD_OPS(elm_bubble)
#include "elm_bubble_eo.c"
free(mark);
}
-EOLIAN static void
-_elm_calendar_elm_layout_sizing_eval(Eo *obj, Elm_Calendar_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_CALENDAR_DATA_GET(obj, sd);
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- if (sd->filling) return;
- // 7x8 (1 month+year, days, 6 dates.)
- elm_coords_finger_size_adjust(7, &minw, 8, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
static inline int
_maxdays_get(struct tm *selected_time, int month_offset)
{
EOLIAN static void
_elm_calendar_efl_canvas_group_group_calculate(Eo *obj, Elm_Calendar_Data *_pd EINA_UNUSED)
{
- elm_layout_freeze(obj);
-
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
_set_headers(obj);
_populate(obj);
-
- elm_layout_thaw(obj);
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
static void
_spinner_buttons_add(obj, priv);
+ // 7x8 (1 month+year, days, 6 dates.)
+ efl_ui_layout_finger_size_multiplier_set(obj, 7, 8);
+
evas_object_smart_changed(obj);
// ACCESS
/* Internal EO APIs and hidden overrides */
#define ELM_CALENDAR_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_calendar), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_calendar)
#include "elm_calendar_eo.c"
}
EOLIAN static void
-_elm_colorselector_elm_layout_sizing_eval(Eo *obj, Elm_Colorselector_Data *sd)
+_elm_colorselector_efl_canvas_group_calculate(Eo *obj, Elm_Colorselector_Data *sd)
{
Evas_Coord minw = -1, minh = -1;
/* Internal EO APIs and hidden overrides */
#define ELM_COLORSELECTOR_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_colorselector), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_colorselector), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_colorselector)
#include "elm_colorselector_eo.c"
{NULL, NULL}
};
-EOLIAN static void
-_elm_dayselector_elm_layout_sizing_eval(Eo *obj, Elm_Dayselector_Data *sd EINA_UNUSED)
-{
- Evas_Coord min_w = -1, min_h = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(ELM_DAYSELECTOR_MAX, &min_w, 1, &min_h);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &min_w, &min_h, min_w, min_h);
- evas_object_size_hint_min_set(obj, min_w, min_h);
-}
-
static void
_dayselector_resize(void *data,
Evas *e EINA_UNUSED,
priv->week_start = _elm_config->week_start;
priv->weekend_start = _elm_config->weekend_start;
priv->weekend_len = _elm_config->weekend_len;
+ efl_ui_layout_finger_size_multiplier_set(obj, ELM_DAYSELECTOR_MAX, 1);
_items_create(obj);
evas_object_event_callback_add
/* Internal EO APIs and hidden overrides */
#define ELM_DAYSELECTOR_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_dayselector), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_dayselector)
#include "elm_dayselector_eo.c"
}
EOLIAN static void
-_elm_entry_elm_layout_sizing_eval(Eo *obj, Elm_Entry_Data *sd)
+_elm_entry_efl_canvas_group_calculate(Eo *obj, Elm_Entry_Data *sd)
{
Evas_Coord minw = -1, minh = -1;
Evas_Coord resw, resh;
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_entry), \
ELM_LAYOUT_CONTENT_ALIASES_OPS(MY_CLASS_PFX), \
ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_entry), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_entry), \
/*********************************************************************************** \
* TIZEN_ONLY_FEATURE: apply Tizen's color_class features. * \
***********************************************************************************/\
};
EOLIAN static void
-_elm_flipselector_elm_layout_sizing_eval(Eo *obj, Elm_Flipselector_Data *sd)
+_elm_flipselector_efl_canvas_group_calculate(Eo *obj, Elm_Flipselector_Data *sd)
{
char *tmp = NULL;
Evas_Coord minw = -1, minh = -1, w, h;
if (sd->sentinel)
{
elm_layout_text_set(obj, "elm.top", tmp);
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
free(tmp);
}
/* Internal EO APIs and hidden overrides */
#define ELM_FLIPSELECTOR_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_flipselector), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_flipselector), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_flipselector)
#include "elm_flipselector_item_eo.c"
//TIZEN_ONLY(20160511) : Remove job for fixing calculate timing issue.
if (!sd->calc_done) _calc(sd->obj);
//
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
if (!sd->nmax) return;
//TIZEN_ONLY(20150825) : Use the specific wanted_region_set func only for gengrid.
}
EOLIAN static void
-_elm_gengrid_elm_layout_sizing_eval(Eo *obj, Elm_Gengrid_Data *sd)
+_elm_gengrid_efl_canvas_group_calculate(Eo *obj, Elm_Gengrid_Data *sd)
{
Evas_Coord minw = 0, minh = 0, maxw = -1, maxh = -1, vw = 0, vh = 0;
/* Internal EO APIs and hidden overrides */
#define ELM_GENGRID_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_gengrid), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_gengrid), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_gengrid)
#include "elm_gengrid_eo.c"
}
EOLIAN static void
-_elm_genlist_elm_layout_sizing_eval(Eo *obj, Elm_Genlist_Data *sd)
+_elm_genlist_efl_canvas_group_calculate(Eo *obj, Elm_Genlist_Data *sd)
{
Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
Evas_Coord vmw = 0, vmh = 0;
Elm_Genlist_Data *sd = psd->wsd;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
evas_event_freeze(e);
if (sd->pan_changed)
/* Internal EO APIs and hidden overrides */
#define ELM_GENLIST_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_genlist), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_genlist), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_genlist)
#define ELM_GENLIST_PAN_EXTRA_OPS \
}
EOLIAN static void
-_elm_hover_elm_layout_sizing_eval(Eo *obj, Elm_Hover_Data *sd)
+_elm_hover_efl_canvas_group_calculate(Eo *obj, Elm_Hover_Data *sd)
{
Evas_Coord ofs_x, x = 0, y = 0, w = 0, h = 0, x2 = 0,
y2 = 0, w2 = 0, h2 = 0;
#define ELM_HOVER_EXTRA_OPS \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_hover), \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_hover), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_hover), \
_ELM_LAYOUT_ALIASES_OPS(elm_hover, content)
#include "elm_hover_eo.c"
}
EOLIAN static void
-_elm_index_elm_layout_sizing_eval(Eo *obj, Elm_Index_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- edje_object_size_min_calc(wd->resize_obj, &minw, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
-EOLIAN static void
_elm_index_item_efl_object_destructor(Eo *eo_item EINA_UNUSED, Elm_Index_Item_Data *it)
{
ELM_INDEX_DATA_GET(WIDGET(it), sd);
/* Internal EO APIs and hidden overrides */
#define ELM_INDEX_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_index), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_index)
#include "elm_index_item_eo.c"
} Elm_Inwin_Data;
EOLIAN static void
-_elm_inwin_elm_layout_sizing_eval(Eo *obj, Elm_Inwin_Data *pd EINA_UNUSED)
+_elm_inwin_efl_canvas_group_calculate(Eo *obj, Elm_Inwin_Data *pd EINA_UNUSED)
{
- Evas_Object *content;
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- content = elm_layout_content_get(obj, NULL);
-
- if (!content) return;
-
- edje_object_size_min_calc(wd->resize_obj, &minw, &minh);
-
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
+ if (elm_layout_content_get(obj, NULL))
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
EOLIAN static void
#define ELM_INWIN_EXTRA_OPS \
EFL_CANVAS_GROUP_ADD_OPS(elm_inwin), \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_inwin)
+ EFL_CANVAS_GROUP_CALC_OPS(elm_inwin)
#include "elm_inwin_eo.c"
}
EOLIAN static void
-_elm_label_elm_layout_sizing_eval(Eo *obj, Elm_Label_Data *_pd EINA_UNUSED)
+_elm_label_efl_canvas_group_calculate(Eo *obj, Elm_Label_Data *_pd EINA_UNUSED)
{
Evas_Coord minw = -1, minh = -1;
Evas_Coord resw, resh;
/* Internal EO APIs and hidden overrides */
#define ELM_LABEL_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_label), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_label), \
EFL_CANVAS_GROUP_ADD_OPS(elm_label)
#include "elm_label_eo.c"
}
EOLIAN static void
-_elm_list_elm_layout_sizing_eval(Eo *obj, Elm_List_Data *sd)
+_elm_list_efl_canvas_group_calculate(Eo *obj, Elm_List_Data *sd)
{
Evas_Coord vw = 0, vh = 0;
Evas_Coord minw = 0, minh = 0, maxw = 0, maxh = 0, w = 0, h = 0, vmw = 0, vmh = 0;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (!efl_finalized_get(obj)) return; //not constructed yet
+ if (efl_canvas_group_need_recalculate_get(sd->box))
+ efl_canvas_group_calculate(sd->box);
+
evas_object_size_hint_combined_min_get(sd->box, &minw, &minh);
evas_object_size_hint_max_get(sd->box, &maxw, &maxh);
evas_object_size_hint_weight_get(sd->box, &xw, &yw);
Evas_Coord mw, mh;
int i, redo = 0;
Eina_Array walk;
+ Eina_Bool hints_changed = EINA_FALSE;
const char *style;
const char *it_odd;
mw = mw > ew ? mw : ew;
mh = mh > eh ? mh : eh;
*/
+ {
+ int pmw, pmh;
+ /* if size changed, flag box for recalc to pull in new sizes */
+ evas_object_size_hint_min_get(VIEW(it), &pmw, &pmh);
+ hints_changed |= pmw != mh || pmh != mh;
+ }
evas_object_size_hint_min_set(VIEW(it), mw, mh);
evas_object_show(VIEW(it));
}
sd->fixing_now = EINA_FALSE;
_elm_list_unwalk(obj, sd);
+ if (hints_changed)
+ efl_canvas_group_need_recalculate_set(sd->box, 1);
//focus highlight in_theme is set by list item theme.
_elm_widget_item_highlight_in_theme(
/* Internal EO APIs and hidden overrides */
#define ELM_LIST_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_list), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_list), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_list)
//TIZEN_ONLY(20171114): list: enhance accessibility scroll and highlight
{
Evas_Coord w, h;
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
if (w <= 0 || h <= 0) return;
}
EOLIAN static void
-_elm_panel_elm_layout_sizing_eval(Eo *obj, Elm_Panel_Data *sd)
+_elm_panel_efl_canvas_group_calculate(Eo *obj, Elm_Panel_Data *sd)
{
- Evas_Coord mw = 0, mh = 0;
-
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (sd->delete_me) return;
else _drawer_open(obj, wd->w, wd->h, EINA_FALSE);
}
- evas_object_smart_calculate(sd->bx);
- edje_object_size_min_calc(wd->resize_obj, &mw, &mh);
- evas_object_size_hint_min_set(obj, mw, mh);
- evas_object_size_hint_max_set(obj, -1, -1);
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
static char *
else
{
efl_content_set(efl_part(efl_super(obj, MY_CLASS), "elm.swallow.content"), priv->bx);
+ /* trigger box recalc on manual panel calc */
+ _efl_ui_layout_subobjs_calc_set(obj, EINA_TRUE);
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
if (edje_object_part_exists
(wd->resize_obj, "elm.swallow.event"))
/* Internal EO APIs and hidden overrides */
#define ELM_PANEL_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_panel), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_panel), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_panel)
#include "elm_panel_eo.c"
# define ELM_LAYOUT_CONTENT_ALIASES_OPS(_pfx) _ELM_LAYOUT_ALIASES_OPS(_pfx, content)
# define ELM_LAYOUT_TEXT_ALIASES_OPS(_pfx) _ELM_LAYOUT_ALIASES_OPS(_pfx, text)
-# define ELM_LAYOUT_SIZING_EVAL_OPS(_pfx) \
- EFL_OBJECT_OP_FUNC(elm_layout_sizing_eval, _##_pfx##_elm_layout_sizing_eval)
+# define EFL_CANVAS_GROUP_CALC_OPS(_pfx) \
+ EFL_OBJECT_OP_FUNC(efl_canvas_group_calculate, _##_pfx##_efl_canvas_group_calculate)
# define ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(_pfx, _typ) \
EOLIAN static Eina_Bool \
}
EOLIAN static void
-_elm_scroller_elm_layout_sizing_eval(Eo *obj, Elm_Scroller_Data *sd)
+_elm_scroller_efl_canvas_group_calculate(Eo *obj, Elm_Scroller_Data *sd)
{
Evas_Coord vw = 0, vh = 0, minw = 0, minh = 0, maxw = 0, maxh = 0, w, h,
vmw, vmh;
/* Internal EO APIs and hidden overrides */
#define ELM_SCROLLER_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_scroller), \
+ EFL_CANVAS_GROUP_CALC_OPS(elm_scroller), \
EFL_CANVAS_GROUP_ADD_OPS(elm_scroller)
#include "elm_scroller_eo.c"
efl_ui_l10n_translation_update(efl_super(obj, MY_CLASS));
}
-EOLIAN static void
-_elm_segment_control_elm_layout_sizing_eval(Eo *obj, Elm_Segment_Control_Data *sd)
-{
- Evas_Coord minw = -1, minh = -1;
- Evas_Coord w, h;
- int item_count;
-
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- item_count = eina_list_count(sd->items);
-
- elm_coords_finger_size_adjust(item_count, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
-
- evas_object_size_hint_combined_min_get(obj, &w, &h);
-
- if (w > minw) minw = w;
- if (h > minh) minh = h;
-
- evas_object_size_hint_min_set(obj, minw, minh);
-}
-
static void
_item_free(Elm_Segment_Control_Item_Data *it)
{
_position_items(sd);
item_count = eina_list_count(sd->items);
+ efl_ui_layout_finger_size_multiplier_set(sd->obj, item_count, 1);
if (item_count == 1)
{
/* Internal EO APIs and hidden overrides */
#define ELM_SEGMENT_CONTROL_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_segment_control), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_segment_control)
#include "elm_segment_control_item_eo.c"
}
EOLIAN static void
-_elm_separator_elm_layout_sizing_eval(Eo *obj, Elm_Separator_Data *sd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- edje_object_size_min_calc(wd->resize_obj, &minw, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
- evas_object_size_hint_align_set(obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
-}
-
-EOLIAN static void
_elm_separator_efl_canvas_group_group_add(Eo *obj, Elm_Separator_Data *sd EINA_UNUSED)
{
efl_canvas_group_add(efl_super(obj, MY_CLASS));
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_canvas_object_type_set(obj, MY_CLASS_NAME_LEGACY);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_SEPARATOR);
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
+ evas_object_size_hint_align_set(obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
return obj;
}
/* Internal EO APIs and hidden overrides */
#define ELM_SEPARATOR_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_separator), \
EFL_CANVAS_GROUP_ADD_OPS(elm_separator)
#include "elm_separator_eo.c"
EOLIAN static void
_elm_slider_efl_canvas_group_group_calculate(Eo *obj, Elm_Slider_Data *sd)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
+ edje_object_freeze(obj);
EFL_UI_SLIDER_DATA_GET(obj, sd2);
- elm_layout_freeze(obj);
if (_is_horizontal(sd2->dir))
evas_object_size_hint_min_set
_units_set(obj);
_indicator_set(obj);
- elm_layout_thaw(obj);
+ edje_object_thaw(obj);
+ efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
static void
return EINA_TRUE;
}
-EOLIAN static void
-_elm_slideshow_elm_layout_sizing_eval(Eo *obj, Elm_Slideshow_Data *_pd EINA_UNUSED)
-{
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
- Evas_Coord minw = -1, minh = -1;
-
- edje_object_size_min_calc(wd->resize_obj, &minw, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, minw, minh);
-}
-
static Elm_Slideshow_Item_Data *
_item_prev_get(Elm_Slideshow_Item_Data *item)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
efl_canvas_group_add(efl_super(obj, MY_CLASS));
+ efl_ui_layout_finger_size_multiplier_set(obj, 0, 0);
priv->count_item_pre_before = 2;
priv->count_item_pre_after = 2;
/* Internal EO APIs and hidden overrides */
#define ELM_SLIDESHOW_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_slideshow), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_slideshow)
#include "elm_slideshow_item_eo.c"
}
}
-EOLIAN static void
-_elm_spinner_elm_layout_sizing_eval(Eo *obj, Elm_Spinner_Data *_pd EINA_UNUSED)
-{
- Evas_Coord minw = -1, minh = -1;
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- edje_object_size_min_restricted_calc
- (wd->resize_obj, &minw, &minh, minw, minh);
- elm_coords_finger_size_adjust(1, &minw, 1, &minh);
- evas_object_size_hint_min_set(obj, minw, minh);
- evas_object_size_hint_max_set(obj, -1, -1);
-}
-
EOLIAN static Eina_Bool
_elm_spinner_efl_ui_focus_object_on_focus_update(Eo *obj, Elm_Spinner_Data *sd)
{
/* Internal EO APIs and hidden overrides */
#define ELM_SPINNER_EXTRA_OPS \
- ELM_LAYOUT_SIZING_EVAL_OPS(elm_spinner), \
EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_spinner)
#include "elm_spinner_eo.c"
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
evas_object_smart_calculate(wd->resize_obj);
}
EOLIAN void
_elm_toolbar_efl_canvas_group_group_calculate(Eo *obj, Elm_Toolbar_Data *pd EINA_UNUSED)
{
+ efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
_sizing_eval(obj);
}
Eina_Bool automatic_orientation_apply : 1;
Eina_Bool model_bound : 1; /**< Set to true once we are watching over a model*/
Eina_Bool model_watch : 1; /**< Set to true once we do watch for model change*/
+ Eina_Bool calc_subobjs : 1; /**< Set to true if group_calc should also handle subobjs during manual calc */
} Efl_Ui_Layout_Data;
/**
if (EINA_UNLIKELY(!efl_isa(obj, EFL_UI_LAYOUT_BASE_CLASS))) \
return
+void _efl_ui_layout_subobjs_calc_set(Eo *obj, Eina_Bool set);
+
#endif
projects / platform / upstream / efl.git / commitdiff