lib/efl/interfaces/efl_pack_linear.eo \
lib/efl/interfaces/efl_pack_table.eo \
lib/efl/interfaces/efl_ui_i18n.eo \
- lib/efl/interfaces/efl_ui_direction.eo \
- lib/efl/interfaces/efl_ui_direction_readonly.eo \
+ lib/efl/interfaces/efl_ui_layout_orientable.eo \
+ lib/efl/interfaces/efl_ui_layout_orientable_readonly.eo \
lib/efl/interfaces/efl_ui_drag.eo \
lib/efl/interfaces/efl_ui_range_display.eo \
lib/efl/interfaces/efl_ui_range_interactive.eo \
lib/efl/interfaces/efl_ui_format.c \
lib/efl/interfaces/efl_gfx_color.c \
lib/efl/interfaces/efl_text_markup_util.c \
-lib/efl/interfaces/efl_ui_direction_readonly.c \
+lib/efl/interfaces/efl_ui_layout_orientable_readonly.c \
$(NULL)
lib_efl_libefl_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl -I$(top_srcdir)/src/lib/efl @EFL_CFLAGS@ -DEFL_GFX_FILTER_BETA -DEFL_BUILD
efl_ui_win_alpha_set(efl_added, 1));
box = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1, 1),
efl_content_set(win, efl_added));
efl_content_set(win, efl_added));
box = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_gfx_hint_weight_set(efl_added, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND),
efl_content_set(win, efl_added));
efl_pack(box, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, box,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, EFL_GFX_HINT_EXPAND, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_pack(box, efl_added));
bx2 = efl_add(EFL_UI_BOX_CLASS, bx);
efl_gfx_hint_weight_set(bx2, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
- efl_ui_direction_set(bx2, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(bx2, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
bt = efl_add(EFL_UI_BUTTON_CLASS, bx2);
efl_text_set(bt, "Sel");
bx2 = efl_add(EFL_UI_BOX_CLASS, bx);
efl_gfx_hint_weight_set(bx2, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
- efl_ui_direction_set(bx2, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(bx2, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
bt = efl_add(EFL_UI_BUTTON_CLASS, bx2);
efl_text_set(bt, "Image");
efl_ui_win_autodel_set(efl_added, 1));
box = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_content_set(win, box);
// FIXME: No API to set background as "tile" :(
efl_content_set(efl_part(ly, "content"), gl);
box2 = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_LTR),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_pack(box, efl_added));
efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _radius_set, win));
box = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_pack_table(table, efl_added, 0, TABLE_SIZE + 1, TABLE_SIZE, 1));
elm_win_autodel_set(win, EINA_TRUE);
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_content_set(win, bx);
td->win = win;
efl_ui_win_autodel_set(efl_added, 1));
box = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_content_set(win, box);
{
box2 = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_align_set(efl_added, 0.5, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE));
{
box2 = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE),
efl_gfx_arrangement_content_padding_set(efl_added, 5, 5, 1),
}
o = split = efl_add(EFL_UI_PANES_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
efl_pack(box, split);
{
efl_content_set(efl_part(split, "first"), flip);
box2 = efl_add(EFL_UI_BOX_STACK_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_gfx_arrangement_content_align_set(efl_added, 0.5, 0.5));
efl_pack(box2, o);
o = box2 = efl_add(EFL_UI_BOX_STACK_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_gfx_arrangement_content_align_set(efl_added, 0.5, 0.5));
unsigned int i;
hbox = efl_add(EFL_UI_BOX_CLASS, box,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1, 1),
efl_pack_end(box, efl_added));
if (!content_class[i]) continue;
hbox = efl_add(EFL_UI_BOX_CLASS, box,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_pack_end(box, efl_added));
radio = efl_add(EFL_UI_RADIO_CLASS, hbox,
efl_content_set(win, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_pack_end(vbox, efl_added));
efl_unref(shadow);
hbx = efl_add(EFL_UI_BOX_CLASS, win);
- efl_ui_direction_set(hbx, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(hbx, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(hbx, EFL_GFX_HINT_EXPAND, 0);
efl_pack(bx, hbx);
efl_unref(shadow);
bt_bx = efl_add(EFL_UI_BOX_CLASS, win);
- efl_ui_direction_set(bt_bx, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(bt_bx, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(bt_bx, EFL_GFX_HINT_EXPAND, 0);
efl_pack(bx, bt_bx);
efl_ui_win_autodel_set(efl_added, EINA_TRUE));
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_content_set(win, efl_added));
efl_add(EFL_UI_TEXT_CLASS, bx,
efl_del(box);
box = efl_add(chk ? EFL_UI_BOX_FLOW_CLASS : EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
efl_content_set(parent, box);
efl_key_wref_set(win, "box", box);
{
Eina_Bool chk = elm_check_selected_get(event->object);
Eo *box = efl_key_wref_get(data, "box");
- efl_ui_direction_set(box, chk ? EFL_UI_DIR_HORIZONTAL : EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(box, chk ? EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL : EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
}
static void
efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400));
vbox = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_arrangement_content_padding_set(vbox, 10, 10, EINA_TRUE);
efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5);
elm_win_resize_object_add(win, vbox);
efl_gfx_entity_visible_set(f, 1);
hbox = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
efl_content_set(f, hbox);
efl_gfx_arrangement_content_padding_set(hbox, 10, 0, EINA_TRUE);
/* weights radio group */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_pack(hbox, bx);
/* misc */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1);
/* user min size setter */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1);
/* inner box padding */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1);
/* outer margin */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1);
/* Box align */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1);
/* Button align */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1);
efl_gfx_entity_visible_set(f, 1);
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
efl_key_wref_set(win, "box", bx);
efl_gfx_arrangement_content_padding_set(bx, 10, 10, EINA_TRUE);
efl_gfx_hint_align_set(bx, 0.5, 0.5);
bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
// Text Only Button
efl_add(EFL_UI_BUTTON_CLASS, bx,
bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_add(EFL_UI_DATEPICKER_CLASS, bx,
efl_ui_datepicker_date_set(efl_added, 1987, 9, 17),
}
box2 = o = efl_add(EFL_UI_BOX_CLASS, box);
- efl_ui_direction_set(o, EFL_UI_DIR_RIGHT);
+ efl_ui_layout_orientation_set(o, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(o, 1.0, 0);
efl_gfx_hint_fill_set(o, EINA_TRUE, EINA_TRUE);
_create_image(win, EINA_FALSE, EINA_FALSE, EINA_FALSE);
hbox = efl_add(EFL_UI_BOX_CLASS, win);
- efl_ui_direction_set(hbox, EFL_UI_DIR_RIGHT);
+ efl_ui_layout_orientation_set(hbox, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_arrangement_content_align_set(hbox, 0, 0.5);
efl_gfx_hint_weight_set(hbox, 1.0, 0.0);
efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_FALSE);
efl_pack(box, hbox);
hbox = efl_add(EFL_UI_BOX_CLASS, win);
- efl_ui_direction_set(hbox, EFL_UI_DIR_RIGHT);
+ efl_ui_layout_orientation_set(hbox, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_arrangement_content_align_set(hbox, 0.5, 0.5);
efl_gfx_hint_weight_set(hbox, 1.0, 0.0);
efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_FALSE),
efl_pack(box, im);
hbox = efl_add(EFL_UI_BOX_CLASS, win);
- efl_ui_direction_set(hbox, EFL_UI_DIR_RIGHT);
+ efl_ui_layout_orientation_set(hbox, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(hbox, 1.0, 1.0);
efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_TRUE);
in_box1 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
sp1 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box1,
efl_ui_range_min_max_set(efl_added, 0,
in_box2 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
sp2 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box2);
efl_ui_format_string_set(efl_part(efl_added, "indicator"), "%1.0f"),
efl_ui_range_min_max_set(efl_added, 0, 3),
efl_ui_range_value_set(efl_added, params->side_page_num),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_gfx_hint_weight_set(efl_added, 1, 1),
efl_gfx_hint_align_set(efl_added, -1, -1),
efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
in_box1 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
sp1 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box1,
efl_ui_range_min_max_set(efl_added, 0,
in_box2 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
sp2 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box2);
);
panes_h = efl_add(EFL_UI_PANES_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_content_set(efl_part(panes, "second"), efl_added)
);
efl_add(EFL_UI_BUTTON_CLASS, win,
btbx = efl_add(EFL_UI_BOX_CLASS, bx,
efl_pack(bx, efl_added),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL)
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
);
pd->btn_start = efl_add(EFL_UI_BUTTON_CLASS, btbx,
btn_text = ((to == layout) ? "parent" : (char *)efl_text_get(to));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added));
efl_pack(box, efl_added));
vbox = efl_add(EFL_UI_BOX_CLASS, f,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_gfx_hint_margin_set(efl_added, 2, 2, 2, 2),
efl_content_set(f, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added));
efl_gfx_hint_align_get(btn, &align_x, &align_y);
hbox = efl_add(EFL_UI_BOX_CLASS, vbox,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added));
efl_pack(hbox, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added));
efl_ui_win_autodel_set(efl_added, EINA_TRUE));
vbox = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
efl_gfx_hint_margin_set(efl_added, 5, 5, 5, 5),
efl_content_set(win, efl_added));
efl_pack(vbox, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, f,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_gfx_arrangement_content_padding_set(efl_added, 10, 0, EINA_TRUE),
efl_content_set(f, efl_added));
efl_content_set(win, efl_added));
bx = efl_add(EFL_UI_BOX_CLASS, sc,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_gfx_hint_weight_set(efl_added, EVAS_HINT_EXPAND, 0),
efl_gfx_hint_align_set(efl_added, 0.5, 0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE),
efl_pack(bx, efl_added));
bx2 = efl_add(EFL_UI_BOX_CLASS, sc2,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_content_set(sc2, efl_added));
for (i = 0; i < 10; i++)
efl_add(EFL_UI_SLIDER_CLASS, bx,
efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(160, 0)),
efl_gfx_hint_weight_set(efl_added, EVAS_HINT_EXPAND, 0.0),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_LEFT),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED),
efl_pack(bx, efl_added));
efl_add(EFL_UI_TEXT_CLASS, bx,
efl_pack(bx, efl_added));
hbx = efl_add(EFL_UI_BOX_CLASS, bx,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_pack(bx, efl_added));
efl_add(EFL_UI_SLIDER_CLASS, hbx,
efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_range_step_set(efl_added, step),
efl_ui_range_value_set(efl_added, 70),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_pack(hbx, efl_added));
efl_add(EFL_UI_SLIDER_CLASS, hbx,
efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(0, 160)),
efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_range_step_set(efl_added, step),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
elm_object_disabled_set(efl_added, EINA_TRUE),
efl_pack(hbx, efl_added));
efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_range_value_set(efl_added, 35),
efl_ui_range_step_set(efl_added, step),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED),
efl_pack(hbx, efl_added));
efl_add(EFL_UI_TEXT_CLASS, bx,
efl_pack(bx, efl_added));
hbx = efl_add(EFL_UI_BOX_CLASS, bx,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_pack(bx, efl_added));
efl_add(EFL_UI_SLIDER_INTERVAL_CLASS, hbx,
efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_slider_interval_value_set(efl_added, 50, 100),
efl_ui_range_step_set(efl_added, step),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_pack(hbx, efl_added));
efl_add(EFL_UI_SLIDER_INTERVAL_CLASS, hbx,
efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_slider_interval_value_set(efl_added, 50, 100),
efl_ui_range_step_set(efl_added, step),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
elm_object_disabled_set(efl_added, EINA_TRUE),
efl_pack(hbx, efl_added));
bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
sp = efl_add(EFL_UI_SPIN_CLASS, bx,
efl_ui_range_min_max_set(efl_added, 0, 10),
bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_add(EFL_UI_SPIN_BUTTON_CLASS, bx,
efl_ui_range_min_max_set(efl_added, 0, 10),
efl_ui_range_value_set(efl_added, 1),
efl_ui_spin_button_editable_set(efl_added, EINA_FALSE),
efl_ui_spin_special_value_set(efl_added, array),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_pack(bx, efl_added));
eina_array_free(array);
in_box = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_pack_end(box, efl_added));
sp = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box,
in_box = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
efl_pack_end(box, efl_added));
sp = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box,
efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400));
vbox = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_arrangement_content_padding_set(vbox, 10, 10, EINA_TRUE);
efl_gfx_hint_weight_set(vbox, 1, 1);
efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5);
efl_gfx_entity_visible_set(f, 1);
hbox = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
elm_object_content_set(f, hbox);
efl_gfx_arrangement_content_padding_set(hbox, 10, 0, EINA_TRUE);
/* weights radio group */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_pack(hbox, bx);
/* min size setter */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1);
efl_pack(hbox, bx);
/* inner box padding */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1);
/* outer margin */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1);
efl_pack(hbox, bx);
/* button margins */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1);
/* button1 aligns */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1);
/* ro info */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1);
efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400));
vbox = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_arrangement_content_padding_set(vbox, 10, 10, EINA_TRUE);
efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5);
elm_win_resize_object_add(win, vbox);
efl_gfx_entity_visible_set(f, 1);
hbox = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
elm_object_content_set(f, hbox);
efl_gfx_arrangement_content_padding_set(hbox, 5, 0, EINA_TRUE);
efl_gfx_entity_visible_set(hbox, 1);
/* ro info */
bx = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_gfx_hint_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1);
efl_gfx_entity_visible_set(f, 1);
efl_pack_table_columns_set(table, 4);
- efl_ui_direction_set(table, EFL_UI_DIR_RIGHT);
+ efl_ui_layout_orientation_set(table, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(table, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_object_content_set(f, table);
efl_gfx_entity_visible_set(table, 1);
bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_DOWN));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_add(EFL_UI_TIMEPICKER_CLASS, bx,
efl_ui_timepicker_time_set(efl_added, 11, 35),
evas_object_show(bg);
box = efl_add(EFL_UI_BOX_CLASS, win,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_HORIZONTAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL));
elm_win_resize_object_add(win, box);
win2 = elm_win_add(win, "inlined", ELM_WIN_INLINED_IMAGE);
win.content_set(box);
efl::ui::Box box_initial(instantiate, win);
- box_initial.direction_set(EFL_UI_DIR_HORIZONTAL);
+ box_initial.orientation_set(EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
box_initial.hint_weight_set(EFL_GFX_HINT_EXPAND, 0.0);
box.pack_end(box_initial);
efl::eolian::event_add(efl::ui::Clickable::clicked_event, btn3, btn_options);
efl::ui::Box box_gap(instantiate, win);
- box_gap.direction_set(EFL_UI_DIR_HORIZONTAL);
+ box_gap.orientation_set(EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
box_gap.hint_weight_set(EFL_GFX_HINT_EXPAND, 0.0);
box.pack_end(box_gap);
up.content_set(icon_up);
efl::ui::Box box_inferior(instantiate, win);
- box_inferior.direction_set(EFL_UI_DIR_HORIZONTAL);
+ box_inferior.orientation_set(EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
box.pack_end(box_inferior);
box_inferior.visible_set(true);
} Grid_Event_Data;
Eo *
-EoGenerate(const Efl_Class *klass, Eo *parent, Efl_Ui_Dir dir)
+EoGenerate(const Efl_Class *klass, Eo *parent, Efl_Ui_Layout_Orientation dir)
{
Eo* obj = efl_add(klass, parent);
- if (dir != EFL_UI_DIR_DEFAULT) efl_ui_direction_set(obj, dir);
+ if (dir != EFL_UI_LAYOUT_ORIENTATION_DEFAULT) efl_ui_layout_orientation_set(obj, dir);
efl_gfx_hint_weight_set(obj, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
efl_gfx_hint_fill_set(obj, EINA_TRUE, EINA_TRUE);
return obj;
efl_text_set(efl_added, "Efl.Ui.Grid"),
efl_ui_win_autodel_set(efl_added, EINA_TRUE));
- box = EoGenerate(EFL_UI_BOX_CLASS, win, EFL_UI_DIR_VERTICAL);
+ box = EoGenerate(EFL_UI_BOX_CLASS, win, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
elm_win_resize_object_add(win, box);
Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, box);
Eina_Bool horiz = 0;
// TEST#1 : Create Grid
- gd->grid = grid = EoGenerate(EFL_UI_GRID_CLASS, box, (horiz ? EFL_UI_DIR_HORIZONTAL : EFL_UI_DIR_VERTICAL));
+ gd->grid = grid = EoGenerate(EFL_UI_GRID_CLASS, box, (horiz ? EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL : EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_ui_grid_item_size_set(grid, EINA_SIZE2D(100, 120)); // 4X4
efl_gfx_arrangement_content_padding_set(grid, 5.0, 5.0, EINA_TRUE);
efl_gfx_arrangement_content_align_set(grid, 0.5, 0.5);
efl_gfx_entity_size_set(win, EINA_SIZE2D(400, 800));
wbox = efl_add(EFL_UI_BOX_CLASS, win);
- efl_ui_direction_set(wbox, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(wbox, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
efl_gfx_hint_weight_set(wbox, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
efl_gfx_hint_fill_set(wbox, EINA_TRUE, EINA_TRUE);
if (emptystyle)
{
ibox = efl_add(EFL_UI_BOX_CLASS, item);
- efl_ui_direction_set(ibox, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(ibox, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
txt = efl_add(EFL_UI_TEXT_CLASS, ibox);
efl_gfx_hint_weight_set(txt, 0.95, EFL_GFX_HINT_EXPAND);
efl_pack_end(wbox, txt);
bbox = efl_add(EFL_UI_BOX_CLASS, wbox);
- efl_ui_direction_set(bbox, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(bbox, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(bbox, EFL_GFX_HINT_EXPAND, 0.05);
select_radio = radio = efl_add(EFL_UI_RADIO_CLASS, wbox);
efl_pack_end(wbox, txt);
priv_d.slider = slider = efl_add(EFL_UI_SLIDER_CLASS, wbox);
- efl_ui_direction_set(slider, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(slider, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(slider, 0.0, 0.05);
efl_gfx_hint_align_set(slider, 0.5, 0.5);
efl_gfx_hint_size_min_set(slider, EINA_SIZE2D(380, 20));
efl_pack_end(wbox, slider);
bbox = efl_add(EFL_UI_BOX_CLASS, wbox);
- efl_ui_direction_set(bbox, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(bbox, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(bbox, EFL_GFX_HINT_EXPAND, 0.05);
rbox = efl_add(EFL_UI_BOX_CLASS, bbox);
- efl_ui_direction_set(rbox, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(rbox, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
anim_radio = radio = efl_add(EFL_UI_RADIO_CLASS, rbox);
efl_gfx_hint_align_set(radio, 0.5, 0.5);
efl_pack_end(bbox, rbox);
rbox = efl_add(EFL_UI_BOX_CLASS, bbox);
- efl_ui_direction_set(rbox, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(rbox, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
scrl_btn = efl_add(EFL_UI_BUTTON_CLASS, rbox);
efl_text_set(scrl_btn, "Scroll Item");
win.autohide_set(true);
efl::ui::Box bx(instantiate, win);
- bx.direction_set(EFL_UI_DIR_HORIZONTAL);
+ bx.orientation_set(EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
win.content_set(bx);
efl::ui::Radio radio(instantiate, win);
efl::ui::Slider sl5(instantiate, win);
sl5.range_min_max_set(0, 100);
sl5.range_step_set(1);
- sl5.direction_set(EFL_UI_DIR_UP);
+ sl5.orientation_set((Efl_Ui_Layout_Orientation)(EFL_UI_LAYOUT_ORIENTATION_VERTICAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED));
sl5.hint_fill_set(true, false);
sl5.hint_size_min_set({0, 120});
bx.pack_end(sl5);
efl::ui::Slider sl6(instantiate, win);
- sl6.direction_set(EFL_UI_DIR_HORIZONTAL);
+ sl6.orientation_set(EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
sl6.range_min_max_set(0, 10);
sl6.hint_fill_set(false, true);
sl6.hint_weight_set(0, EFL_GFX_HINT_EXPAND);
return evas_obj_box_count(pd->rp->object);
}
-EOLIAN static Efl_Ui_Dir
-_efl_canvas_layout_part_box_efl_ui_direction_direction_get(const Eo *obj, void *_pd EINA_UNUSED)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_canvas_layout_part_box_efl_ui_layout_orientable_orientation_get(const Eo *obj, void *_pd EINA_UNUSED)
{
PROXY_DATA_GET(obj, pd);
const Edje_Part_Description_Box *desc =
(Edje_Part_Description_Box *) pd->rp->chosen_description;
if (!desc || !desc->box.layout)
- return EFL_UI_DIR_DEFAULT;
+ return EFL_UI_LAYOUT_ORIENTATION_DEFAULT;
if (!strncmp(desc->box.layout, "vertical", 8))
- return EFL_UI_DIR_VERTICAL;
+ return EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
else if (!strncmp(desc->box.layout, "horizontal", 10))
- return EFL_UI_DIR_HORIZONTAL;
+ return EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
WRN("unknown orientation '%s'", desc->box.layout);
- return EFL_UI_DIR_DEFAULT;
+ return EFL_UI_LAYOUT_ORIENTATION_DEFAULT;
}
#include "efl_canvas_layout_part_box.eo.c"
EDJE_PART_INVALID(Efl_Gfx_Entity *, 0, efl_pack_content_get, _efl_canvas_layout_part_invalid_efl_pack_linear_pack_content_get, int index)
EDJE_PART_INVALID(Efl_Gfx_Entity *, 0, efl_pack_unpack_at, _efl_canvas_layout_part_invalid_efl_pack_linear_pack_unpack_at, int index)
EDJE_PART_INVALID(int, 0, efl_pack_index_get, _efl_canvas_layout_part_invalid_efl_pack_linear_pack_index_get, const Efl_Gfx_Entity *subobj)
-EDJE_PART_INVALID_CONST(Efl_Ui_Dir, 0, efl_ui_direction_get, _efl_canvas_layout_part_invalid_efl_ui_direction_direction_get)
+EDJE_PART_INVALID_CONST(Efl_Ui_Layout_Orientation, 0, efl_ui_layout_orientation_get, _efl_canvas_layout_part_invalid_efl_ui_layout_orientable_orientation_get)
EDJE_PART_INVALID(Eina_Bool, 0, efl_pack_table, _efl_canvas_layout_part_invalid_efl_pack_table_pack_table, Efl_Gfx_Entity *subobj, int col, int row, int colspan, int rowspan)
EDJE_PART_INVALID(Efl_Gfx_Entity *, 0, efl_pack_table_content_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_content_get, int col, int row)
EDJE_PART_INVALID(Eina_Iterator *, 0, efl_pack_table_contents_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_contents_get, int col, int row, Eina_Bool below)
class @beta Efl.Canvas.Layout_Part_Box extends Efl.Canvas.Layout_Part implements Efl.Pack_Linear,
- Efl.Ui.Direction_Readonly
+ Efl.Ui.Layout_Orientable_Readonly
{
[[Represents a Box created as part of a layout.
Efl.Pack_Linear.pack_content_get;
Efl.Pack_Linear.pack_unpack_at;
Efl.Pack_Linear.pack_index_get;
- Efl.Ui.Direction.direction { get; [[Returns $default if unknown.]] }
+ Efl.Ui.Layout_Orientable.orientation { get; [[Returns $default if unknown.]] }
}
}
class @beta Efl.Canvas.Layout_Part_Invalid extends Efl.Canvas.Layout_Part implements Efl.Content,
- Efl.Pack_Linear, Efl.Ui.Direction_Readonly,
+ Efl.Pack_Linear, Efl.Ui.Layout_Orientable_Readonly,
Efl.Pack_Table, Efl.Text,
Efl.Text_Markup, Efl.Text_Markup_Interactive
{
Efl.Pack_Linear.pack_content_get;
Efl.Pack_Linear.pack_unpack_at;
Efl.Pack_Linear.pack_index_get;
- Efl.Ui.Direction.direction { get; [[Returns $default if unknown.]] }
+ Efl.Ui.Layout_Orientable.orientation { get; [[Returns $default if unknown.]] }
// Efl.Canvas.Layout_Part_Table
Efl.Pack_Table.pack_table;
Efl.Pack_Table.table_content_get;
#include "interfaces/efl_text.eo.h"
#include "interfaces/efl_text_types.eot.h"
#include "interfaces/efl_ui_i18n.eo.h"
-#include "interfaces/efl_ui_direction.eo.h"
-#include "interfaces/efl_ui_direction_readonly.eo.h"
+#include "interfaces/efl_ui_layout_orientable.eo.h"
+#include "interfaces/efl_ui_layout_orientable_readonly.eo.h"
#include "interfaces/efl_ui_drag.eo.h"
#include "interfaces/efl_ui_range_display.eo.h"
#include "interfaces/efl_ui_range_interactive.eo.h"
-parse efl_ui_direction;
+parse efl_ui_layout_orientable;
enum @beta Efl.Gfx.Image_Orientation
{
its roof pointing to the right if the $right orientation is used).
Flipping values ($flip_horizontal and $flip_vertical) can be additionaly added
to produce a mirroring in each axis.
- Not to be confused with @Efl.Ui.Dir which is meant for widgets, rather
+ Not to be confused with @Efl.Ui.Layout_Orientation which is meant for widgets, rather
than images and canvases. This enum is used to rotate images, videos and
the like.
]]
#include "interfaces/efl_model.eo.c"
#include "interfaces/efl_interpolator.eo.c"
#include "interfaces/efl_ui_i18n.eo.c"
-#include "interfaces/efl_ui_direction.eo.c"
+#include "interfaces/efl_ui_layout_orientable.eo.c"
#include "interfaces/efl_ui_drag.eo.c"
#include "interfaces/efl_ui_range_display.eo.c"
#include "interfaces/efl_ui_range_interactive.eo.c"
+++ /dev/null
-// FIXME: Documentation lacks proper references due to cyclic imports.
-// FIXME: What about AnyRTL? And other strange directions?
-
-parse efl_gfx_image_orientable;
-
-enum @beta Efl.Ui.Dir
-{
- [[Direction for UI objects and layouts.
-
- Not to be confused with @Efl.Gfx.Image_Orientation which is for images and canvases. This
- enum is used to define how widgets should expand and orient themselves,
- not to rotate images.
-
- See also @Efl.Ui.Direction.
- ]]
- default = 0,[[Default direction. Each widget may have a different default.]]
- horizontal, [[Horizontal direction, along the X axis. Usually left-to-right,
- but may be inverted to right-to-left if mirroring is on.]]
- vertical, [[Vertical direction, along the Y axis. Usually downwards.]]
- ltr, [[Horizontal, left-to-right direction.]]
- rtl, [[Horizontal, right-to-left direction.]]
- down, [[Vertical, top-to-bottom direction.]]
- up, [[Vertical, bottom-to-top direction.]]
- right = Efl.Ui.Dir.ltr, [[Right is an alias for LTR.]]
- left = Efl.Ui.Dir.rtl, [[Left is an alias for RTL.]]
-}
-
-interface @beta Efl.Ui.Direction
-{
- [[EFL UI object direction interface]]
- methods {
- @property direction {
- [[Control the direction of a given widget.
-
- Use this function to change how your widget is to be disposed:
- vertically or horizontally or inverted vertically or inverted
- horizontally.
-
- Mirroring as defined in @Efl.Ui.I18n can invert the $horizontal
- direction: it is $ltr by default, but becomes $rtl if the object
- is mirrored.
- ]]
- values {
- dir: Efl.Ui.Dir; [[Direction of the widget.]]
- }
- }
- }
-}
+++ /dev/null
-#ifdef HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#include <Efl.h>
-
-typedef struct {
-
-} Efl_Ui_Direction_Readonly_Data;
-
-EOLIAN static void
-_efl_ui_direction_readonly_efl_ui_direction_direction_set(Eo *obj EINA_UNUSED, Efl_Ui_Direction_Readonly_Data *pd EINA_UNUSED, Efl_Ui_Dir dir EINA_UNUSED)
-{
- EINA_LOG_ERR("This object does not allow setting of a direction");
-}
-
-#include "interfaces/efl_ui_direction_readonly.eo.c"
+++ /dev/null
-mixin @beta Efl.Ui.Direction_Readonly extends Efl.Ui.Direction
-{
- implements {
- Efl.Ui.Direction.direction { set; [[This will always print and error that this is a readonly object]]}
- }
-}
--- /dev/null
+parse efl_gfx_image_orientable;
+
+enum @beta Efl.Ui.Layout_Orientation
+{
+ [[Orientation for UI objects and layouts that can have multiple configurations.
+
+ Select among $horizontal or $vertical orientations (or use $default to let the
+ object decide). Additionally, $inverted can be added to reverse the direction
+ along the selected axis.
+
+ Not to be confused with @Efl.Gfx.Image_Orientation which is for images and canvases. This
+ enum is used to define how widgets should expand and orient themselves,
+ not to rotate images.
+
+ See also @Efl.Ui.Layout_Orientable.
+ ]]
+ default = 0, [[Default direction. Each widget may have a different default.]]
+ horizontal = 1, [[Horizontal direction, along the X axis. Usually left-to-right,
+ but can be inverted.]]
+ vertical = 2, [[Vertical direction, along the Y axis. Usually downwards but
+ can be inverted.]]
+ axis_bitmask = 3, [[This bitmask can be used to isolate the axis value from the rest of bits.]]
+ inverted = 4 [[Add this value to make the object invert its default direction
+ along the selected axis.]]
+}
+
+interface @beta Efl.Ui.Layout_Orientable
+{
+ [[Interface for UI objects which can have more than one orientation.
+
+ For example, sliders, which can be horizontal or vertical, or container
+ boxes, which can arrange their elements in a horizontal or vertical fashion.
+ ]]
+ c_prefix: efl_ui_layout;
+ methods {
+ @property orientation {
+ [[Control the direction of a given widget.
+
+ Use this function to change how your widget is to be disposed:
+ vertically or horizontally or inverted vertically or inverted
+ horizontally.
+
+ Mirroring as defined in @Efl.Ui.I18n can invert the $horizontal
+ direction: it is $ltr by default, but becomes $rtl if the object
+ is mirrored.
+ ]]
+ values {
+ dir: Efl.Ui.Layout_Orientation; [[Direction of the widget.]]
+ }
+ }
+ }
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Efl.h>
+
+typedef struct {
+
+} Efl_Ui_Layout_Orientable_Readonly_Data;
+
+EOLIAN static void
+_efl_ui_layout_orientable_readonly_efl_ui_layout_orientable_orientation_set(Eo *obj EINA_UNUSED, Efl_Ui_Layout_Orientable_Readonly_Data *pd EINA_UNUSED, Efl_Ui_Layout_Orientation dir EINA_UNUSED)
+{
+ EINA_LOG_ERR("This object does not allow setting an orientation");
+}
+
+#include "interfaces/efl_ui_layout_orientable_readonly.eo.c"
--- /dev/null
+mixin @beta Efl.Ui.Layout_Orientable_Readonly extends Efl.Ui.Layout_Orientable
+{
+ implements {
+ Efl.Ui.Layout_Orientable.orientation { set; [[This will always print an error saying that this is a readonly object.]] }
+ }
+}
'efl_pack_table.eo',
'efl_gfx_arrangement.eo',
'efl_ui_i18n.eo',
- 'efl_ui_direction.eo',
- 'efl_ui_direction_readonly.eo',
+ 'efl_ui_layout_orientable.eo',
+ 'efl_ui_layout_orientable_readonly.eo',
'efl_ui_drag.eo',
'efl_ui_range_display.eo',
'efl_ui_range_interactive.eo',
'efl_observer.c',
'efl_file.c',
'efl_ui_format.c',
- 'efl_ui_direction_readonly.c',
+ 'efl_ui_layout_orientable_readonly.c',
'efl_text_markup_util.c',
])
if (spd->pager.obj)
{
- efl_ui_direction_set(spd->idbox, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(spd->idbox, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_arrangement_content_padding_set(spd->idbox, 15, 15, EINA_TRUE);
pd->v = eina_value_float_new(0.0);
efl_canvas_object_type_set(obj, MY_CLASS_NAME);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_FILLER);
- pd->dir = EFL_UI_DIR_VERTICAL;
+ pd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
pd->align.h = 0.5;
pd->align.v = 0.5;
}
EOLIAN static void
-_efl_ui_box_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Box_Data *pd, Efl_Ui_Dir dir)
+_efl_ui_box_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_Box_Data *pd, Efl_Ui_Layout_Orientation dir)
{
if (pd->dir == dir) return;
switch (dir)
{
- case EFL_UI_DIR_RTL:
- // FIXME: Should be inverted!
- case EFL_UI_DIR_HORIZONTAL:
- case EFL_UI_DIR_LTR:
- pd->dir = EFL_UI_DIR_HORIZONTAL;
+ case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
+ pd->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
break;
- case EFL_UI_DIR_UP:
- // FIXME: Should be inverted!
- case EFL_UI_DIR_DOWN:
- case EFL_UI_DIR_VERTICAL:
- case EFL_UI_DIR_DEFAULT:
+ case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
+ case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
default:
- pd->dir = EFL_UI_DIR_VERTICAL;
+ pd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
break;
}
efl_pack_layout_request(obj);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_box_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Box_Data *pd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_box_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Box_Data *pd)
{
return pd->dir;
}
class @beta Efl.Ui.Box extends Efl.Ui.Widget implements Efl.Pack_Linear, Efl.Pack_Layout,
- Efl.Ui.Direction, Efl.Gfx.Arrangement
+ Efl.Ui.Layout_Orientable, Efl.Gfx.Arrangement
{
[[The box widget.
Efl.Gfx.Entity.size { set; }
Efl.Container.content_iterate;
Efl.Container.content_count;
- Efl.Ui.Direction.direction { get; set; }
+ Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Pack.pack_clear;
Efl.Pack.unpack_all;
Efl.Pack.unpack;
Item_Calc *items, *item;
Row_Calc *rows, *row;
Efl_Ui_Container_Item_Hints *hints, *hint;
- Eina_Bool axis = !efl_ui_dir_is_horizontal(bd->dir, EINA_FALSE);
+ Eina_Bool axis = !efl_ui_layout_orientation_is_horizontal(bd->dir, EINA_FALSE);
Eina_Bool c_axis = !axis;
int want[2] = { 0, 0 };
int rc = 0, count, i = 0, id, item_last = 0;
Eina_Inlist *inlist = NULL;
Item_Calc *items, *item;
Efl_Ui_Container_Item_Hints *hints, *hint;
- Eina_Bool axis = !efl_ui_dir_is_horizontal(pd->dir, EINA_FALSE);
+ Eina_Bool axis = !efl_ui_layout_orientation_is_horizontal(pd->dir, EINA_FALSE);
Eina_Bool r_axis = !axis;
int want[2] = { 0, 0 };
int count, i = 0;
struct _Efl_Ui_Box_Data
{
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
Eo *clipper;
Eina_List *children;
efl_ui_range_min_max_set(efl_added, 1970, 2037),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
pd->month = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_min_max_set(efl_added, 1, 12),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
pd->day = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_min_max_set(efl_added, 1, 31),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
DATE_GET();
return sd->intmode;
}
-static Efl_Ui_Dir
+static Efl_Ui_Layout_Orientation
_flip_dir_to_efl_ui_dir(Elm_Flip_Direction dir)
{
switch (dir)
{
- case ELM_FLIP_DIRECTION_RIGHT: return EFL_UI_DIR_RIGHT;
- case ELM_FLIP_DIRECTION_DOWN: return EFL_UI_DIR_DOWN;
- case ELM_FLIP_DIRECTION_LEFT: return EFL_UI_DIR_LEFT;
- case ELM_FLIP_DIRECTION_UP: return EFL_UI_DIR_UP;
+ case ELM_FLIP_DIRECTION_RIGHT: return EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
+ case ELM_FLIP_DIRECTION_DOWN: return EFL_UI_LAYOUT_ORIENTATION_VERTICAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED;
+ case ELM_FLIP_DIRECTION_LEFT: return EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED;
+ case ELM_FLIP_DIRECTION_UP: return EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
}
ERR("Invalid value for Elm_Flip_Direction: %d", (int) dir);
- return EFL_UI_DIR_DEFAULT;
+ return EFL_UI_LAYOUT_ORIENTATION_DEFAULT;
}
static Elm_Flip_Direction
-_efl_ui_dir_to_flip_dir(Efl_Ui_Dir dir)
+_efl_ui_dir_to_flip_dir(Efl_Ui_Layout_Orientation dir)
{
switch (dir)
{
- case EFL_UI_DIR_RIGHT:
- case EFL_UI_DIR_HORIZONTAL:
+ case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
return ELM_FLIP_DIRECTION_RIGHT;
- case EFL_UI_DIR_DOWN:
+ case EFL_UI_LAYOUT_ORIENTATION_VERTICAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED:
return ELM_FLIP_DIRECTION_DOWN;
- case EFL_UI_DIR_LEFT:
+ case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED:
return ELM_FLIP_DIRECTION_LEFT;
- case EFL_UI_DIR_UP:
- case EFL_UI_DIR_VERTICAL:
- case EFL_UI_DIR_DEFAULT:
+ case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
+ case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
return ELM_FLIP_DIRECTION_UP;
}
- ERR("Invalid value for Efl_Ui_Dir: %d", (int) dir);
+ ERR("Invalid value for Efl_Ui_Layout_Orientation: %d", (int) dir);
return ELM_FLIP_DIRECTION_UP;
}
EOLIAN static void
-_efl_ui_flip_interaction_direction_enabled_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir, Eina_Bool enabled)
+_efl_ui_flip_interaction_direction_enabled_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Ui_Layout_Orientation dir, Eina_Bool enabled)
{
int i = _efl_ui_dir_to_flip_dir(dir);
int area;
}
EOLIAN static Eina_Bool
-_efl_ui_flip_interaction_direction_enabled_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir)
+_efl_ui_flip_interaction_direction_enabled_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Ui_Layout_Orientation dir)
{
return sd->dir_enabled[_efl_ui_dir_to_flip_dir(dir)];
}
EOLIAN static void
-_efl_ui_flip_interaction_direction_hitsize_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir, double hitsize)
+_efl_ui_flip_interaction_direction_hitsize_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Ui_Layout_Orientation dir, double hitsize)
{
int i = _efl_ui_dir_to_flip_dir(dir);
}
EOLIAN static double
-_efl_ui_flip_interaction_direction_hitsize_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir)
+_efl_ui_flip_interaction_direction_hitsize_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Ui_Layout_Orientation dir)
{
int i = _efl_ui_dir_to_flip_dir(dir);
EAPI void
elm_flip_interaction_direction_hitsize_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, double hitsize)
{
- Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
+ Efl_Ui_Layout_Orientation uidir = _flip_dir_to_efl_ui_dir(dir);
efl_ui_flip_interaction_direction_hitsize_set(obj, uidir, hitsize);
}
EAPI double
elm_flip_interaction_direction_hitsize_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir)
{
- Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
+ Efl_Ui_Layout_Orientation uidir = _flip_dir_to_efl_ui_dir(dir);
return efl_ui_flip_interaction_direction_hitsize_get(obj, uidir);
}
EOAPI void
elm_flip_interaction_direction_enabled_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, Eina_Bool enabled)
{
- Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
+ Efl_Ui_Layout_Orientation uidir = _flip_dir_to_efl_ui_dir(dir);
efl_ui_flip_interaction_direction_enabled_set(obj, uidir, enabled);
}
EOAPI Eina_Bool
elm_flip_interaction_direction_enabled_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir)
{
- Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
+ Efl_Ui_Layout_Orientation uidir = _flip_dir_to_efl_ui_dir(dir);
return efl_ui_flip_interaction_direction_enabled_get(obj, uidir);
}
-import efl_ui_direction;
+import efl_ui_layout_orientable;
enum @beta Efl.Ui.Flip_Mode
{
See also @.interaction.set.
]]
params {
- @in dir: Efl.Ui.Dir; [[The hit area to set.]]
+ @in dir: Efl.Ui.Layout_Orientation; [[The hit area to set.]]
@in hitsize: double; [[The amount of that dimension (0.0 to 1.0) to use.]]
}
}
[[Get the amount of the flip that is sensitive to interactive flip.]]
return: double; [[The size set for that direction.]]
params {
- @in dir: Efl.Ui.Dir; [[The direction to check.]]
+ @in dir: Efl.Ui.Layout_Orientation; [[The direction to check.]]
}
}
interaction_direction_enabled_set {
hit area will be created on the opposite edge of the flip.
]]
params {
- @in dir: Efl.Ui.Dir; [[The direction to change.]]
+ @in dir: Efl.Ui.Layout_Orientation; [[The direction to change.]]
@in enabled: bool; [[If that direction is enabled or not.]]
}
}
[[Get the enabled state of that flip direction.]]
return: bool; [[If that direction is enabled or not.]]
params {
- @in dir: Efl.Ui.Dir; [[The direction to check.]]
+ @in dir: Efl.Ui.Layout_Orientation; [[The direction to check.]]
}
}
go {
Eina_Bool horiz = 0;
Eina_Size2D min, max;
- if (pd->dir == EFL_UI_DIR_HORIZONTAL) horiz = 1;
+ if (pd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL) horiz = 1;
if (!pd->linemax)
{
view = efl_ui_scrollable_viewport_geometry_get(pd->smanager);
vpos = efl_ui_scrollable_content_pos_get(pd->smanager);
- if (pd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (pd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
{
ipos.y = view.y;
//ipos.h = ipos.h;
}
EOLIAN static void
-_efl_ui_grid_efl_ui_direction_direction_set(Eo *obj EINA_UNUSED, Efl_Ui_Grid_Data *pd, Efl_Ui_Dir dir)
+_efl_ui_grid_efl_ui_layout_orientable_orientation_set(Eo *obj EINA_UNUSED, Efl_Ui_Grid_Data *pd, Efl_Ui_Layout_Orientation dir)
{
//FIXME: Currently only support horizontal and vertical mode.
switch (dir)
{
- case EFL_UI_DIR_RTL:
- // FIXME: Should be inverted!
- case EFL_UI_DIR_HORIZONTAL:
- case EFL_UI_DIR_LTR:
- pd->dir = EFL_UI_DIR_HORIZONTAL;
+ case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
+ pd->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
break;
-
- case EFL_UI_DIR_UP:
- // FIXME: Should be inverted!
- case EFL_UI_DIR_DOWN:
- case EFL_UI_DIR_VERTICAL:
- case EFL_UI_DIR_DEFAULT:
+ case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
+ case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
default:
- pd->dir = EFL_UI_DIR_VERTICAL;
+ pd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
break;
}
efl_pack_layout_request(obj);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_grid_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Grid_Data *pd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_grid_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Grid_Data *pd)
{
return pd->dir;
}
Efl.Ui.Scrollable_Interactive,
Efl.Ui.Scrollbar,
Efl.Pack_Linear, Efl.Pack_Layout,
- Efl.Ui.Direction,
+ Efl.Ui.Layout_Orientable,
Efl.Ui.Selectable,
Efl.Ui.Multi_Selectable,
Efl.Gfx.Arrangement
Efl.Container.content_iterate;
Efl.Container.content_count;
- Efl.Ui.Direction.direction { get; set; }
+ Efl.Ui.Layout_Orientable.orientation { get; set; }
//Efl.Ui.Widget
Efl.Ui.Widget.theme_apply;
Eo *smanager; /* Scroll Manager for support scroll with pan */
Eina_Rect geo;
Eina_Position2D pre_pos;
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
struct {
Efl_Ui_Grid_Item *item; /* Scroll target item */
return efl_pack_index_get(pack, subobj);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_layout_part_box_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Layout_Box_Data *pd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_layout_part_box_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Layout_Box_Data *pd)
{
- ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EFL_UI_DIR_DEFAULT);
+ ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EFL_UI_LAYOUT_ORIENTATION_DEFAULT);
- return efl_ui_direction_get(efl_part(wd->resize_obj, pd->part));
+ return efl_ui_layout_orientation_get(efl_part(wd->resize_obj, pd->part));
}
/* TIZEN_ONLY(20180508): fix layout_part_cursor things and eo hierarchy of part_box/part_table
class @beta Efl.Ui.Layout_Part_Box extends Efl.Object implements Efl.Pack_Linear,
- Efl.Ui.Direction_Readonly
+ Efl.Ui.Layout_Orientable_Readonly
*/
/* END */
class @beta Efl.Ui.Layout_Part_Box extends Efl.Ui.Layout_Part implements Efl.Pack_Linear,
- Efl.Ui.Direction_Readonly
+ Efl.Ui.Layout_Orientable_Readonly
{
[[Represents a Box created as part of a layout.
Efl.Object.destructor;
Efl.Container.content_iterate;
Efl.Container.content_count;
- Efl.Ui.Direction.direction { get; }
+ Efl.Ui.Layout_Orientable.orientation { get; }
Efl.Pack.pack_clear;
Efl.Pack.unpack_all;
Efl.Pack.unpack;
edje_object_part_swallow(wd->resize_obj, "efl.content", pd->pan);
pd->box = efl_add(EFL_UI_BOX_CLASS, obj,
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
efl_ui_mirrored_set(pd->box, efl_ui_mirrored_get(obj));
efl_content_set(pd->pan, pd->box);
/* FIXME: Direction is not supported yet in the list
EOLIAN static void
- _efl_ui_list_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_List_Data *pd, Efl_Ui_Dir dir)
+ _efl_ui_list_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_List_Data *pd, Efl_Ui_Layout_Orientation dir)
{
switch (dir)
{
- case EFL_UI_DIR_RTL:
- // FIXME: Should be inverted!
- case EFL_UI_DIR_HORIZONTAL:
- case EFL_UI_DIR_LTR:
- pd->dir = EFL_UI_DIR_HORIZONTAL;
+ case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
+ pd->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
break;
-
- case EFL_UI_DIR_UP:
- // FIXME: Should be inverted!
- case EFL_UI_DIR_DOWN:
- case EFL_UI_DIR_VERTICAL:
- case EFL_UI_DIR_DEFAULT:
+ case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
+ case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
default:
- pd->dir = EFL_UI_DIR_VERTICAL;
+ pd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
break;
}
Efl.Container.content_iterate;
Efl.Container.content_count;
- //Efl.Ui.Direction.direction { get; set; } //TODO
+ //Efl.Ui.Layout_Orientable.orientation { get; set; } //TODO
//Efl.Ui.Widget
Efl.Ui.Widget.theme_apply;
}
}
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
eina_strbuf_append(new_group, "horizontal");
else
eina_strbuf_append(new_group, "vertical");
sd->second_min = efl_gfx_hint_size_min_get(second_content);
}
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
{
min.w = MAX(sd->first_min.w, sd->second_min.w);
min.h = sd->first_min.h + sd->second_min.h;
evas_object_geometry_get(wd->resize_obj, NULL, NULL, &w, &h);
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
{
if (first_min.h + second_min.h > h)
{
sizer = sizer / sum;
sizel = sizel / sum;
}
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
{
edje_object_part_drag_value_set
(wd->resize_obj, "right_constraint", 0.0, (1 - sizer));
if (sd->right_min_size_is_relative)
{
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
sd->right_min_size = (int)(h * sd->right_min_relative_size);
else
sd->right_min_size =(int)(w * sd->right_min_relative_size);
else
{
sd->right_min_relative_size = 0;
- if (sd->dir == EFL_UI_DIR_HORIZONTAL && (h > 0))
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL && (h > 0))
sd->right_min_relative_size = sd->right_min_size / (double)h;
- if (sd->dir == EFL_UI_DIR_VERTICAL && (w > 0))
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_VERTICAL && (w > 0))
sd->right_min_relative_size = sd->right_min_size / (double)w;
}
if(sd->left_min_size_is_relative)
{
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
sd->left_min_size = (int)(h * sd->left_min_relative_size);
else
sd->left_min_size = (int)(w * sd->left_min_relative_size);
else
{
sd->left_min_relative_size = 0;
- if (sd->dir == EFL_UI_DIR_HORIZONTAL && (h > 0))
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL && (h > 0))
sd->left_min_relative_size = sd->left_min_size / (double)h;
- if (sd->dir == EFL_UI_DIR_VERTICAL && (w > 0))
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_VERTICAL && (w > 0))
sd->left_min_relative_size = sd->left_min_size / (double)w;
}
(wd->resize_obj, EVAS_CALLBACK_RESIZE,
_on_resize, obj);
- sd->dir = EFL_UI_DIR_VERTICAL;
+ sd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
sd->right_min_size_is_relative = EINA_TRUE;
sd->left_min_size_is_relative = EINA_TRUE;
sd->right_min_size = 0;
else
edje_object_part_drag_value_get(wd->resize_obj, "efl.bar", &w, &h);
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
return h;
else return w;
}
if (ratio < 0.0) ratio = 0.0;
else if (ratio > 1.0) ratio = 1.0;
- if (sd->dir == EFL_UI_DIR_HORIZONTAL)
+ if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
{
if (elm_widget_is_legacy(obj))
edje_object_part_drag_value_set(wd->resize_obj, "elm.bar", 0.0, ratio);
}
EOLIAN static void
-_efl_ui_panes_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Panes_Data *sd, Efl_Ui_Dir dir)
+_efl_ui_panes_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_Panes_Data *sd, Efl_Ui_Layout_Orientation dir)
{
double size = elm_panes_content_left_size_get(obj);
- if (efl_ui_dir_is_horizontal(dir, EINA_FALSE))
- dir = EFL_UI_DIR_HORIZONTAL;
+ if (efl_ui_layout_orientation_is_horizontal(dir, EINA_FALSE))
+ dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else
- dir = EFL_UI_DIR_VERTICAL;
+ dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
sd->dir = dir;
efl_ui_widget_theme_apply(obj);
elm_panes_content_left_size_set(obj, size);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_panes_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Panes_Data *sd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_panes_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Panes_Data *sd)
{
return sd->dir;
}
{
EFL_UI_PANES_CHECK(obj);
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
if (horizontal)
- dir = EFL_UI_DIR_HORIZONTAL;
+ dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else
- dir = EFL_UI_DIR_VERTICAL;
+ dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
- efl_ui_direction_set(obj, dir);
+ efl_ui_layout_orientation_set(obj, dir);
}
EAPI Eina_Bool
{
EFL_UI_PANES_CHECK(obj) EINA_FALSE;
- Efl_Ui_Dir dir = efl_ui_direction_get(obj);
+ Efl_Ui_Layout_Orientation dir = efl_ui_layout_orientation_get(obj);
- if (dir == EFL_UI_DIR_HORIZONTAL)
+ if (dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
return EINA_TRUE;
return EINA_FALSE;
-class @beta Efl.Ui.Panes extends Efl.Ui.Layout_Base implements Efl.Ui.Direction,
+class @beta Efl.Ui.Panes extends Efl.Ui.Layout_Base implements Efl.Ui.Layout_Orientable,
Efl.Ui.Clickable
{
[[Elementary panes class]]
implements {
Efl.Object.constructor;
Efl.Ui.Widget.theme_apply;
- Efl.Ui.Direction.direction { get; set; [[Only supports $vertical and $horizontal. Default is $vertical.]] }
+ Efl.Ui.Layout_Orientable.orientation { get; set; [[Only supports $vertical and $horizontal. Default is $vertical.]] }
Efl.Part.part_get;
//TIZEN_ONLY(20180607): Restore legacy focus
Efl.Ui.Widget.focus_next_manager_is;
Eina_Bool move;
} move;
- Efl_Ui_Dir dir;
- double left_min_relative_size;
- double right_min_relative_size;
- Eina_Size2D first_min, second_min;
- double first_min_split_ratio, second_min_split_ratio;
+ Efl_Ui_Layout_Orientation dir;
+ double left_min_relative_size;
+ double right_min_relative_size;
+ Eina_Size2D first_min, second_min;
+ double first_min_split_ratio, second_min_split_ratio;
- Evas_Coord left_min_size;
- Evas_Coord right_min_size;
- Eina_Bool double_clicked : 1;
- Eina_Bool fixed : 1;
- Eina_Bool left_min_size_is_relative : 1;
- Eina_Bool right_min_size_is_relative : 1;
- Eina_Bool first_hint_min_allow : 1;
- Eina_Bool second_hint_min_allow : 1;
+ Evas_Coord left_min_size;
+ Evas_Coord right_min_size;
+ Eina_Bool double_clicked : 1;
+ Eina_Bool fixed : 1;
+ Eina_Bool left_min_size_is_relative : 1;
+ Eina_Bool right_min_size_is_relative : 1;
+ Eina_Bool first_hint_min_allow : 1;
+ Eina_Bool second_hint_min_allow : 1;
};
/**
}
static inline Eina_Bool
-_is_horizontal(Efl_Ui_Dir dir)
+_is_horizontal(Efl_Ui_Layout_Orientation dir)
{
- return efl_ui_dir_is_horizontal(dir, EINA_TRUE);
-}
-
-static inline Eina_Bool
-_is_inverted(Efl_Ui_Dir dir)
-{
- if ((dir == EFL_UI_DIR_LEFT) || (dir == EFL_UI_DIR_UP))
- return EINA_TRUE;
-
- return EINA_FALSE;
-}
-
-static Efl_Ui_Dir
-_direction_get(Eina_Bool horizontal, Eina_Bool inverted)
-{
- if (horizontal)
- {
- if (inverted)
- return EFL_UI_DIR_LEFT;
- else
- return EFL_UI_DIR_RIGHT;
- }
- else
- {
- if (inverted)
- return EFL_UI_DIR_UP;
- else
- return EFL_UI_DIR_DOWN;
- }
+ return efl_ui_layout_orientation_is_horizontal(dir, EINA_TRUE);
}
static void
static void
_val_set(Evas_Object *obj)
{
- Eina_Bool rtl;
double pos;
Efl_Ui_Progress_Status *ps;
Eina_List *l;
EFL_UI_PROGRESSBAR_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
- rtl = efl_ui_mirrored_get(obj);
-
EINA_LIST_FOREACH(sd->progress_status, l, ps)
{
if (EINA_DBL_EQ(ps->val_max, ps->val_min))
}
pos = (ps->val - ps->val_min)/(ps->val_max - ps->val_min);
- if ((!rtl && _is_inverted(sd->dir)) ||
- (rtl && ((sd->dir == EFL_UI_DIR_UP) ||
- (sd->dir == EFL_UI_DIR_RIGHT))))
+ if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
pos = MAX_RATIO_LVL - pos;
edje_object_part_drag_value_set
if (elm_widget_is_legacy(obj))
{
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
elm_layout_signal_emit(obj, "elm,state,inverted,on", "elm");
else
elm_layout_signal_emit(obj, "elm,state,inverted,off", "elm");
}
else
{
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
elm_layout_signal_emit(obj, "efl,state,inverted,on", "efl");
else
elm_layout_signal_emit(obj, "efl,state,inverted,off", "efl");
elm_widget_theme_klass_set(obj, "progressbar");
efl_canvas_group_add(efl_super(obj, MY_CLASS));
- priv->dir = EFL_UI_DIR_RIGHT;
+ priv->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
priv->val = MIN_RATIO_LVL;
priv->val_max = 1.0;
group = _efl_ui_progressbar_theme_group_get(obj, priv);
}
EOLIAN static void
-_efl_ui_progressbar_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Progressbar_Data *sd, Efl_Ui_Dir dir)
+_efl_ui_progressbar_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_Progressbar_Data *sd, Efl_Ui_Layout_Orientation dir)
{
if (sd->dir == dir) return;
efl_ui_widget_theme_apply(obj);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_progressbar_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Progressbar_Data *sd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_progressbar_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Progressbar_Data *sd)
{
return sd->dir;
}
EAPI void
elm_progressbar_inverted_set(Evas_Object *obj, Eina_Bool inverted)
{
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
EFL_UI_PROGRESSBAR_DATA_GET_OR_RETURN(obj, sd);
- dir = _direction_get(_is_horizontal(sd->dir), inverted);
+ dir = sd->dir & EFL_UI_LAYOUT_ORIENTATION_AXIS_BITMASK;
+ if (inverted) dir |= EFL_UI_LAYOUT_ORIENTATION_INVERTED;
- efl_ui_direction_set(obj, dir);
+ efl_ui_layout_orientation_set(obj, dir);
}
EAPI Eina_Bool
{
EFL_UI_PROGRESSBAR_DATA_GET_OR_RETURN(obj, sd, EINA_FALSE);
- return _is_inverted(sd->dir);
+ return efl_ui_layout_orientation_is_inverted(sd->dir);
}
EAPI void
elm_progressbar_horizontal_set(Evas_Object *obj, Eina_Bool horizontal)
{
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
EFL_UI_PROGRESSBAR_DATA_GET_OR_RETURN(obj, sd);
- dir = _direction_get(horizontal, _is_inverted(sd->dir));
+ dir = horizontal ? EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL : EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
+ dir |= (sd->dir & EFL_UI_LAYOUT_ORIENTATION_INVERTED);
- efl_ui_direction_set(obj, dir);
+ efl_ui_layout_orientation_set(obj, dir);
}
typedef struct
class @beta Efl.Ui.Progressbar extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Display, Efl.Ui.Format,
- Efl.Ui.Direction, Efl.Access.Value,
+ Efl.Ui.Layout_Orientable, Efl.Access.Value,
Efl.Text, Efl.Content, Efl.Text_Markup
{
[[Elementary progressbar class]]
Efl.Ui.Widget.theme_apply;
Efl.Ui.Range_Display.range_value { get; set; }
Efl.Ui.Range_Display.range_min_max {get; set; }
- Efl.Ui.Direction.direction { get; set; }
+ Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Ui.Format.format_cb { set; }
Efl.Part.part_get;
Efl.Access.Value.value_and_text { get; }
void *format_cb_data;
Eina_Strbuf *format_strbuf;
- Efl_Ui_Dir dir; /**< Orientation of the progressbar */
+ Efl_Ui_Layout_Orientation dir; /**< Orientation of the progressbar */
Eina_Bool pulse : 1; /**< Whether object is put in the pulsing mode */
Eina_Bool pulse_state : 1; /**< To start the pulsing animation, otherwise to stop it */
}
static inline Eina_Bool
-_is_horizontal(Efl_Ui_Dir dir)
+_is_horizontal(Efl_Ui_Layout_Orientation dir)
{
- return efl_ui_dir_is_horizontal(dir, EINA_TRUE);
-}
-
-static inline Eina_Bool
-_is_inverted(Efl_Ui_Dir dir)
-{
- if ((dir == EFL_UI_DIR_LEFT) || (dir == EFL_UI_DIR_DOWN))
- return EINA_TRUE;
-
- return EINA_FALSE;
+ return efl_ui_layout_orientation_is_horizontal(dir, EINA_TRUE);
}
static void
_efl_ui_slider_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Data *sd, Eina_Bool user_event)
{
- Eina_Bool rtl;
double posx = 0.0, posy = 0.0, pos = 0.0, val;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (_is_horizontal(sd->dir)) pos = posx;
else pos = posy;
- rtl = efl_ui_mirrored_get(obj);
- if ((!rtl && _is_inverted(sd->dir)) ||
- (rtl && ((sd->dir == EFL_UI_DIR_UP) ||
- (sd->dir == EFL_UI_DIR_RIGHT))))
+ if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
{
pos = 1.0 - pos;
}
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
- Eina_Bool rtl;
double pos;
if (sd->val_max > sd->val_min)
else if (pos > 1.0)
pos = 1.0;
- rtl = efl_ui_mirrored_get(obj);
- if ((!rtl && _is_inverted(sd->dir)) ||
- (rtl && ((sd->dir == EFL_UI_DIR_UP) ||
- (sd->dir == EFL_UI_DIR_RIGHT))))
+ if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
{
pos = 1.0 - pos;
}
EFL_UI_SLIDER_DATA_GET(data, sd);
step = sd->step;
- if (_is_inverted(sd->dir)) step *= -1.0;
+ if (efl_ui_layout_orientation_is_inverted(sd->dir)) step *= -1.0;
ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
if (elm_widget_is_legacy(obj))
EFL_UI_SLIDER_DATA_GET(data, sd);
step = -sd->step;
- if (_is_inverted(sd->dir)) step *= -1.0;
+ if (efl_ui_layout_orientation_is_inverted(sd->dir)) step *= -1.0;
ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
if (elm_widget_is_legacy(obj))
{
if (!_is_horizontal(sd->dir))
return EINA_FALSE;
- if (!_is_inverted(sd->dir))
+ if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL);
}
{
if (!_is_horizontal(sd->dir))
return EINA_FALSE;
- if (!_is_inverted(sd->dir))
+ if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL);
}
{
if (_is_horizontal(sd->dir))
return EINA_FALSE;
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL);
}
{
if (_is_horizontal(sd->dir))
return EINA_FALSE;
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL);
}
if ((act == EFL_UI_ACTIVATE_UP) ||
(act == EFL_UI_ACTIVATE_RIGHT))
{
- if (!_is_inverted(sd->dir))
+ if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL);
}
else if ((act == EFL_UI_ACTIVATE_DOWN) ||
(act == EFL_UI_ACTIVATE_LEFT))
{
- if (!_is_inverted(sd->dir))
+ if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL);
}
if (elm_widget_is_legacy(obj))
{
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
efl_layout_signal_emit(obj, "elm,state,inverted,on", "elm");
else
efl_layout_signal_emit(obj, "elm,state,inverted,off", "elm");
}
else
{
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
efl_layout_signal_emit(obj, "efl,state,inverted,on", "efl");
else
efl_layout_signal_emit(obj, "efl,state,inverted,off", "efl");
free(group);
- priv->dir = EFL_UI_DIR_RIGHT;
+ priv->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
priv->val_max = 1.0;
priv->step = SLIDER_STEP;
}
EOLIAN static void
-_efl_ui_slider_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Slider_Data *sd, Efl_Ui_Dir dir)
+_efl_ui_slider_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_Slider_Data *sd, Efl_Ui_Layout_Orientation dir)
{
sd->dir = dir;
efl_ui_widget_theme_apply(obj);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_slider_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Data *sd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_slider_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Data *sd)
{
return sd->dir;
}
-class @beta Efl.Ui.Slider extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Interactive, Efl.Ui.Direction,
+class @beta Efl.Ui.Slider extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Interactive, Efl.Ui.Layout_Orientable,
Efl.Access.Value,
Efl.Access.Widget.Action
{
Efl.Ui.Range_Display.range_value { get; set; }
Efl.Ui.Range_Display.range_min_max {get; set; }
Efl.Ui.Range_Interactive.range_step { get; set; }
- Efl.Ui.Direction.direction { get; set; }
+ Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Access.Value.value_and_text { get; set; }
Efl.Access.Value.range { get; }
Efl.Access.Value.increment { get; }
else
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable.slider"),
&posx, &posy);
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) pos = posx;
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos = posx;
else pos = posy;
if (elm_widget_is_legacy(obj))
else
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable2.slider"),
&posx2, &posy2);
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) pos2 = posx2;
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos2 = posx2;
else pos2 = posy2;
val = (pos * (sd->val_max - sd->val_min)) + sd->val_min;
&posx2, &posy2);
}
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
diff1 = fabs(button_x - posx);
diff2 = fabs(button_x - posx2);
typedef struct _Efl_Ui_Slider_Data Efl_Ui_Slider_Data;
struct _Efl_Ui_Slider_Data
{
- Evas_Object *spacer;
- Ecore_Timer *delay;
+ Evas_Object *spacer;
+ Ecore_Timer *delay;
- double val, val_min, val_max, step;
+ double val, val_min, val_max, step;
- Evas_Coord downx, downy;
- Efl_Ui_Dir dir;
+ Evas_Coord downx, downy;
+ Efl_Ui_Layout_Orientation dir;
- Eina_Bool spacer_down : 1;
- Eina_Bool frozen : 1;
+ Eina_Bool spacer_down : 1;
+ Eina_Bool frozen : 1;
};
/**
}
}
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
eina_strbuf_append(new_group, "horizontal");
else
eina_strbuf_append(new_group, "vertical");
}
EOLIAN static void
-_efl_ui_spin_button_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Spin_Button_Data *sd, Efl_Ui_Dir dir)
+_efl_ui_spin_button_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_Spin_Button_Data *sd, Efl_Ui_Layout_Orientation dir)
{
if (sd->dir == dir) return;
efl_ui_widget_theme_apply(obj);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_spin_button_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_spin_button_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd)
{
return sd->dir;
}
-class @beta Efl.Ui.Spin_Button extends Efl.Ui.Spin implements Efl.Ui.Focus.Composition, Efl.Ui.Direction,
+class @beta Efl.Ui.Spin_Button extends Efl.Ui.Spin implements Efl.Ui.Focus.Composition, Efl.Ui.Layout_Orientable,
Efl.Access.Widget.Action
{
[[A Button Spin.
Efl.Ui.Widget.widget_input_event_handler;
Efl.Ui.Focus.Object.on_focus_update;
Efl.Ui.Range_Display.range_value { set; }
- Efl.Ui.Direction.direction { get; set; }
+ Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Access.Object.i18n_name { get; }
Efl.Access.Value.value_and_text { get; set; }
Efl.Access.Value.range { get; }
Ecore_Timer *spin_timer; /**< a timer for a repeated spinner value change on mouse down */
Ecore_Timer *longpress_timer; /**< a timer to detect long press. After longpress timeout,
start continuous change of values until mouse up */
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
Eina_Bool entry_visible : 1;
Eina_Bool entry_reactivate : 1;
EFL_UI_TAB_BAR_DATA_GET(obj, sd);
- horizontal = efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE);
+ horizontal = efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE);
_els_box_layout
(o, priv, horizontal, EINA_TRUE, efl_ui_mirrored_get(obj));
elm_widget_theme_style_get(obj)) == EFL_UI_THEME_APPLY_ERROR_GENERIC)
CRI("Failed to set layout!");
- sd->dir = EFL_UI_DIR_HORIZONTAL;
+ sd->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
sd->bx = evas_object_box_add(evas_object_evas_get(obj));
evas_object_box_align_set(sd->bx, 0.5, 0.5);
evas_object_box_layout_set(sd->bx, _layout, obj, NULL);
Efl_Canvas_Object *bx;
int cnt;
int cur;
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
Eina_List *tab_infos;
Tab_Info *selected_tab;
efl_pack_table_size_get(obj, &req_cols, &req_rows);
- if (efl_ui_dir_is_horizontal(pd->fill_dir, EINA_TRUE))
+ if (efl_ui_layout_orientation_is_horizontal(pd->fill_dir, EINA_TRUE))
{
EINA_INLIST_REVERSE_FOREACH(EINA_INLIST_GET(pd->items), gi)
{
//efl_access_object_access_type_set(obj, EFL_ACCESS_TYPE_SKIPPED);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_FILLER);
- pd->fill_dir = EFL_UI_DIR_RIGHT;
+ pd->fill_dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
pd->last_col = -1;
pd->last_row = -1;
pd->req_cols = 0;
}
EOLIAN static void
-_efl_ui_table_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Table_Data *pd, Efl_Ui_Dir dir)
+_efl_ui_table_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_Table_Data *pd, Efl_Ui_Layout_Orientation dir)
{
if (pd->fill_dir == dir)
return;
- if (dir == EFL_UI_DIR_DEFAULT)
- dir = EFL_UI_DIR_RIGHT;
+ if (dir == EFL_UI_LAYOUT_ORIENTATION_DEFAULT)
+ dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
pd->fill_dir = dir;
efl_pack_layout_request(obj);
}
-EOLIAN static Efl_Ui_Dir
-_efl_ui_table_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Table_Data *pd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_efl_ui_table_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Table_Data *pd)
{
return pd->fill_dir;
}
_efl_ui_table_last_position_get(obj, pd, &last_col, &last_row);
- if (efl_ui_dir_is_horizontal(pd->fill_dir, EINA_TRUE))
+ if (efl_ui_layout_orientation_is_horizontal(pd->fill_dir, EINA_TRUE))
{
last_col++;
if (pd->req_cols && (last_col >= pd->req_cols))
class @beta Efl.Ui.Table extends Efl.Ui.Widget implements Efl.Pack_Table, Efl.Pack_Layout,
- Efl.Ui.Direction, Efl.Gfx.Arrangement
+ Efl.Ui.Layout_Orientable, Efl.Gfx.Arrangement
{
[[Widget container that arranges its elements in a grid.
The amount of rows and columns can be controlled with @Efl.Pack_Table.table_rows
and @Efl.Pack_Table.table_columns, and elements can be manually positioned with
@Efl.Pack_Table.pack_table.
- Additionally, a fill direction can be defined with @Efl.Ui.Direction.direction and
+ Additionally, a fill direction can be defined with @Efl.Ui.Layout_Orientable.orientation and
elements added with @Efl.Pack.pack. Elements are then added following this direction
(horizontal or vertical) and when the amount of columns or rows has been reached,
a step is taken in the orthogonal direction.
In this second case there is no need to define both the amount of columns and rows,
as the table will expand as needed.
- The default fill direction is @Efl.Ui.Dir.right.
+ The default fill direction is @Efl.Ui.Layout_Orientation.horizontal.
]]
methods {
@property homogeneous {
Efl.Gfx.Entity.size { set; }
Efl.Container.content_iterate;
Efl.Container.content_count;
- Efl.Ui.Direction.direction { get; set; }
+ Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Pack.pack_clear;
Efl.Pack.unpack_all;
Efl.Pack.unpack;
int cols, rows;
int req_cols, req_rows; // requested - 0 means infinite
int last_col, last_row; // only used by pack api
- Efl_Ui_Dir fill_dir; // direction in which cells are added when using pack()
+ Efl_Ui_Layout_Orientation fill_dir; // direction in which cells are added when using pack()
struct {
double h, v;
Eina_Bool scalable: 1;
efl_ui_range_min_max_set(efl_added, 1, 12),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
pd->min = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_min_max_set(efl_added, 0, 59),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL),
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
pd->ampm = efl_add(EFL_UI_BUTTON_CLASS, obj,
static inline void
_palette_box_prepare(Eo *o)
{
- efl_ui_direction_set(o, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(o, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
efl_gfx_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
efl_gfx_entity_visible_set(o, EINA_FALSE);
}
ELM_INDEX_DATA_GET(data, sd);
Eina_Bool horizontal;
- horizontal = efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE);
+ horizontal = efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE);
_els_box_layout(o, priv, horizontal, EINA_TRUE, efl_ui_mirrored_get(data));
}
if (sd->omit_enabled)
{
o = edje_object_add(evas_object_evas_get(obj));
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE))
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE))
{
elm_widget_theme_object_set
(obj, o, "index", "item/horizontal", style);
edje_object_mirrored_set(VIEW(it), rtl);
o = VIEW(it);
/* TIZEN_ONLY(20160630) : implement elm_index_item_elm_widget_item_style_set
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE))
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE))
*/
if (it->style)
elm_widget_theme_object_set(obj, o, "index", it->style, elm_widget_style_get(obj));
- else if (efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE))
+ else if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE))
/* END */
{
if (i & 0x1)
_index_box_clear(obj, 0);
_index_box_clear(obj, 1);
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE))
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE))
elm_widget_theme_element_set(obj, "base/horizontal");
else
elm_widget_theme_element_set(obj, "base/vertical");
x = (x * x) + (y * y);
if ((x < dist) || (!it_closest))
{
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE))
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE))
cdv = (double)(xx - bx) / (double)bw;
else
cdv = (double)(yy - by) / (double)bh;
(wd->resize_obj, "elm.dragable.pointer",
(!edje_object_mirrored_get(wd->resize_obj)) ?
x : (x - w), y);
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE) && (sd->event_rect[1]))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE) && (sd->event_rect[1]))
{
if (adx > minw)
{
evas_object_show(priv->bx[0]);
priv->delay_change_time = INDEX_DELAY_CHANGE_TIME;
+<<<<<<< HEAD
// TIZEN ONLY(20150527) : Enable omit as default
priv->omit_enabled = EINA_TRUE;
//
priv->dir = EFL_UI_DIR_VERTICAL;
+=======
+ priv->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
+>>>>>>> 38d7d33354... Rename Efl.Ui.Direction -> Efl.Ui.Layout_Orientation
if (edje_object_part_exists
(wd->resize_obj, "elm.swallow.index.1"))
EAPI void elm_index_horizontal_set(Evas_Object *obj, Eina_Bool horizontal)
{
- Efl_Ui_Dir dir = horizontal ? EFL_UI_DIR_HORIZONTAL : EFL_UI_DIR_VERTICAL;
+ Efl_Ui_Layout_Orientation dir = horizontal ? EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL : EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
- efl_ui_direction_set(obj, dir);
+ efl_ui_layout_orientation_set(obj, dir);
}
EAPI Eina_Bool elm_index_horizontal_get(const Evas_Object *obj)
{
- Efl_Ui_Dir dir = efl_ui_direction_get(obj);
+ Efl_Ui_Layout_Orientation dir = efl_ui_layout_orientation_get(obj);
- return efl_ui_dir_is_horizontal(dir, EINA_FALSE);
+ return efl_ui_layout_orientation_is_horizontal(dir, EINA_FALSE);
}
EOLIAN static Eo *
}
EOLIAN static void
-_elm_index_efl_ui_direction_direction_set(Eo *obj, Elm_Index_Data *sd, Efl_Ui_Dir dir)
+_elm_index_efl_ui_layout_orientable_orientation_set(Eo *obj, Elm_Index_Data *sd, Efl_Ui_Layout_Orientation dir)
{
// Adjust direction to be either horizontal or vertical.
- if (efl_ui_dir_is_horizontal(dir, EINA_FALSE))
- dir = EFL_UI_DIR_HORIZONTAL;
+ if (efl_ui_layout_orientation_is_horizontal(dir, EINA_FALSE))
+ dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else
- dir = EFL_UI_DIR_VERTICAL;
+ dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
sd->dir = dir;
efl_ui_widget_theme_apply(obj);
}
-EOLIAN static Efl_Ui_Dir
-_elm_index_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Elm_Index_Data *sd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_elm_index_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Elm_Index_Data *sd)
{
return sd->dir;
}
void _elm_index_efl_ui_widget_on_access_update(Eo *obj, Elm_Index_Data *pd, Eina_Bool enable);
-void _elm_index_efl_ui_direction_direction_set(Eo *obj, Elm_Index_Data *pd, Efl_Ui_Dir dir);
+void _elm_index_efl_ui_layout_orientable_orientation_set(Eo *obj, Elm_Index_Data *pd, Efl_Ui_Layout_Orientation dir);
-Efl_Ui_Dir _elm_index_efl_ui_direction_direction_get(const Eo *obj, Elm_Index_Data *pd);
+Efl_Ui_Layout_Orientation _elm_index_efl_ui_layout_orientable_orientation_get(const Eo *obj, Elm_Index_Data *pd);
Eina_List *_elm_index_efl_access_object_access_children_get(const Eo *obj, Elm_Index_Data *pd);
EFL_OBJECT_OP_FUNC(efl_constructor, _elm_index_efl_object_constructor),
EFL_OBJECT_OP_FUNC(efl_ui_widget_theme_apply, _elm_index_efl_ui_widget_theme_apply),
EFL_OBJECT_OP_FUNC(efl_ui_widget_on_access_update, _elm_index_efl_ui_widget_on_access_update),
- EFL_OBJECT_OP_FUNC(efl_ui_direction_set, _elm_index_efl_ui_direction_direction_set),
- EFL_OBJECT_OP_FUNC(efl_ui_direction_get, _elm_index_efl_ui_direction_direction_get),
+ EFL_OBJECT_OP_FUNC(efl_ui_layout_orientation_set, _elm_index_efl_ui_layout_orientable_orientation_set),
+ EFL_OBJECT_OP_FUNC(efl_ui_layout_orientation_get, _elm_index_efl_ui_layout_orientable_orientation_get),
EFL_OBJECT_OP_FUNC(efl_access_object_access_children_get, _elm_index_efl_access_object_access_children_get),
EFL_OBJECT_OP_FUNC(efl_ui_widget_screen_reader, _elm_index_efl_ui_widget_screen_reader),
EFL_OBJECT_OP_FUNC(efl_access_component_highlight_grab, _elm_index_efl_access_component_highlight_grab),
NULL
};
-EFL_DEFINE_CLASS(elm_index_class_get, &_elm_index_class_desc, EFL_UI_LAYOUT_BASE_CLASS, EFL_UI_DIRECTION_INTERFACE, EFL_UI_CLICKABLE_MIXIN, EFL_UI_SELECTABLE_INTERFACE, EFL_UI_LEGACY_INTERFACE, NULL);
+EFL_DEFINE_CLASS(elm_index_class_get, &_elm_index_class_desc, EFL_UI_LAYOUT_BASE_CLASS, EFL_UI_LAYOUT_ORIENTABLE_INTERFACE, EFL_UI_CLICKABLE_MIXIN, EFL_UI_SELECTABLE_INTERFACE, EFL_UI_LEGACY_INTERFACE, NULL);
#include "elm_index_eo.legacy.c"
return EINA_TRUE; \
}
+static inline Efl_Ui_Layout_Orientation
+efl_ui_layout_orientation_axis_get(Efl_Ui_Layout_Orientation orient)
+{
+ return orient & EFL_UI_LAYOUT_ORIENTATION_AXIS_BITMASK;
+}
+
+static inline Eina_Bool
+efl_ui_layout_orientation_is_inverted(Efl_Ui_Layout_Orientation orient)
+{
+ return orient & EFL_UI_LAYOUT_ORIENTATION_INVERTED;
+}
+
static inline Eina_Bool
-efl_ui_dir_is_horizontal(Efl_Ui_Dir dir, Eina_Bool def_val)
+efl_ui_layout_orientation_is_horizontal(Efl_Ui_Layout_Orientation orient, Eina_Bool def_val)
{
- switch (dir)
+ switch (orient & EFL_UI_LAYOUT_ORIENTATION_AXIS_BITMASK)
{
- case EFL_UI_DIR_DEFAULT: return !!def_val;
- case EFL_UI_DIR_HORIZONTAL: return EINA_TRUE;
- case EFL_UI_DIR_VERTICAL: return EINA_FALSE;
- case EFL_UI_DIR_LTR: return EINA_TRUE;
- case EFL_UI_DIR_RTL: return EINA_TRUE;
- case EFL_UI_DIR_DOWN: return EINA_FALSE;
- case EFL_UI_DIR_UP: return EINA_FALSE;
+ case EFL_UI_LAYOUT_ORIENTATION_DEFAULT: return !!def_val;
+ case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL: return EINA_TRUE;
+ case EFL_UI_LAYOUT_ORIENTATION_VERTICAL: return EINA_FALSE;
default: return !!def_val;
}
}
}
static inline Eina_Bool
-_is_horizontal(Efl_Ui_Dir dir)
+_is_horizontal(Efl_Ui_Layout_Orientation dir)
{
- return efl_ui_dir_is_horizontal(dir, EINA_TRUE);
-}
-
-static inline Eina_Bool
-_is_inverted(Efl_Ui_Dir dir)
-{
- if ((dir == EFL_UI_DIR_LEFT) || (dir == EFL_UI_DIR_UP))
- return EINA_TRUE;
-
- return EINA_FALSE;
-}
-
-static Efl_Ui_Dir
-_direction_get(Eina_Bool horizontal, Eina_Bool inverted)
-{
- if (horizontal)
- {
- if (inverted)
- return EFL_UI_DIR_LEFT;
- else
- return EFL_UI_DIR_RIGHT;
- }
- else
- {
- if (inverted)
- return EFL_UI_DIR_UP;
- else
- return EFL_UI_DIR_DOWN;
- }
+ return efl_ui_layout_orientation_is_horizontal(dir, EINA_TRUE);
}
static void
EFL_UI_SLIDER_DATA_GET(data, sd);
step = sd->step;
- if (_is_inverted(sd->dir)) step *= -1.0;
+ if (efl_ui_layout_orientation_is_inverted(sd->dir)) step *= -1.0;
ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
efl_ui_drag_step_move(efl_part(wd->resize_obj, "elm.dragable.slider"),
EFL_UI_SLIDER_DATA_GET(data, sd);
step = -sd->step;
- if (_is_inverted(sd->dir)) step *= -1.0;
+ if (efl_ui_layout_orientation_is_inverted(sd->dir)) step *= -1.0;
ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
efl_ui_drag_step_move(efl_part(wd->resize_obj, "elm.dragable.slider"),
{
if (!_is_horizontal(sd->dir))
return EINA_FALSE;
- if (!_is_inverted(sd->dir))
+ if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL);
}
{
if (!_is_horizontal(sd->dir))
return EINA_FALSE;
- if (!_is_inverted(sd->dir))
+ if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL);
}
{
if (_is_horizontal(sd->dir))
return EINA_FALSE;
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL);
}
{
if (_is_horizontal(sd->dir))
return EINA_FALSE;
- if (_is_inverted(sd->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL);
}
edje_object_scale_set(popup, efl_gfx_entity_scale_get(obj) *
elm_config_scale_get());
- if (!_is_inverted(sd2->dir))
+ if (!efl_ui_layout_orientation_is_inverted(sd2->dir))
edje_object_signal_emit(popup, "elm,state,inverted,off", "elm");
else
edje_object_signal_emit(popup, "elm,state,inverted,on", "elm");
void
_elm_slider_val_fetch(Evas_Object *obj, Elm_Slider_Data *pd, Eina_Bool user_event)
{
- Eina_Bool rtl;
double posx = 0.0, posy = 0.0, pos = 0.0, val;
double posx2 = 0.0, posy2 = 0.0, pos2 = 0.0, val2;
Eina_Bool inverted = EINA_FALSE;
efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable.slider"),
&posx, &posy);
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) pos = posx;
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos = posx;
else pos = posy;
//TIZEN_ONLY(20190102): added check for existence of parts
efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable2.slider"),
&posx2, &posy2);
//
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) pos2 = posx2;
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos2 = posx2;
else pos2 = posy2;
- rtl = efl_ui_mirrored_get(obj);
- if ((!rtl && _is_inverted(sd->dir)) ||
- (rtl && ((sd->dir == EFL_UI_DIR_UP) ||
- (sd->dir == EFL_UI_DIR_RIGHT))))
+ if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
{
pos = 1.0 - pos;
pos2 = 1.0 - pos2;
void
_elm_slider_val_set(Evas_Object *obj, Elm_Slider_Data *pd EINA_UNUSED)
{
- Eina_Bool rtl;
double pos, pos2;
EFL_UI_SLIDER_DATA_GET(obj, sd);
else if (pos2 > 1.0)
pos2 = 1.0;
- rtl = efl_ui_mirrored_get(obj);
- if ((!rtl && _is_inverted(sd->dir)) ||
- (rtl && ((sd->dir == EFL_UI_DIR_UP) ||
- (sd->dir == EFL_UI_DIR_RIGHT))))
+ if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
{
pos = 1.0 - pos;
pos2 = 1.0 - pos2;
&posx2, &posy2);
//
- if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
diff1 = fabs(button_x - posx);
diff2 = fabs(button_x - posx2);
else
elm_layout_signal_emit(obj, "elm,slider,range,disable", "elm");
- if (_is_inverted(sd2->dir))
+ if (efl_ui_layout_orientation_is_inverted(sd2->dir))
elm_layout_signal_emit(obj, "elm,state,inverted,on", "elm");
else
elm_layout_signal_emit(obj, "elm,state,inverted,off", "elm");
EAPI void
elm_slider_horizontal_set(Evas_Object *obj, Eina_Bool horizontal)
{
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
EFL_UI_SLIDER_DATA_GET_OR_RETURN(obj, sd2);
- dir = _direction_get(horizontal, _is_inverted(sd2->dir));
+ dir = horizontal ? EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL : EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
+ dir |= (sd2->dir & EFL_UI_LAYOUT_ORIENTATION_INVERTED);
- efl_ui_direction_set(obj, dir);
+ efl_ui_layout_orientation_set(obj, dir);
}
EAPI Eina_Bool
{
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
- Efl_Ui_Dir dir;
- dir = efl_ui_direction_get(obj);
+ Efl_Ui_Layout_Orientation dir;
+ dir = efl_ui_layout_orientation_get(obj);
return _is_horizontal(dir);
}
EAPI void
elm_slider_inverted_set(Evas_Object *obj, Eina_Bool inverted)
{
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
EFL_UI_SLIDER_DATA_GET_OR_RETURN(obj, sd2);
- dir = _direction_get(_is_horizontal(sd2->dir), inverted);
+ dir = sd2->dir & EFL_UI_LAYOUT_ORIENTATION_AXIS_BITMASK;
+ if (inverted) dir |= EFL_UI_LAYOUT_ORIENTATION_INVERTED;
- efl_ui_direction_set(obj, dir);
+ efl_ui_layout_orientation_set(obj, dir);
}
EAPI Eina_Bool
elm_slider_inverted_get(const Evas_Object *obj)
{
- Efl_Ui_Dir dir;
- dir = efl_ui_direction_get(obj);
+ Efl_Ui_Layout_Orientation dir;
+ dir = efl_ui_layout_orientation_get(obj);
- return _is_inverted(dir);
+ return efl_ui_layout_orientation_is_inverted(dir);
}
typedef struct
if (sd->more_item)
{
evas_object_geometry_get(sd->VIEW(more_item), NULL, NULL, &ciw, &cih);
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) *iw += cih;
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) *iw += cih;
else *iw += ciw;
}
if (it->prio.priority > sd->standard_priority)
{
evas_object_geometry_get(VIEW(it), NULL, NULL, &ciw, &cih);
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) *iw += cih;
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) *iw += cih;
else *iw += ciw;
//expand is the case where the bx_more stuff is used and the prio.visible is completly ignored.
//if this is the case - then every item in there is just visible in the box - nothing (beside the items in the other box is hidden)
if (mw != -1 || mh != -1)
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) min = mh;
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) min = mh;
else min = mw;
if ((!full) && ((sumf + min) > view))
{
Evas_Coord iw = 0, ih = 0, more_w = 0, more_h = 0;
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
h = vh;
_items_visibility_fix(obj, sd, &ih, vh, EINA_FALSE, &more);
evas_object_geometry_get
(sd->VIEW(more_item), NULL, NULL, &more_w, &more_h);
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
if ((ih - more_h) <= vh) ih -= more_h;
}
* individual items won't trigger a resize. Items are be
* readded below. */
evas_object_box_remove_all(sd->bx, EINA_FALSE);
- if ((!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) ||
- ( efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) ||
+ if ((!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) ||
+ ( efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) ||
more)
{
Evas_Object *menu;
{
Evas_Coord iw = 0, ih = 0;
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
h = vh;
_items_visibility_fix(obj, sd, &ih, vh, EINA_FALSE, &more);
_items_visibility_fix(obj, sd, &iw, vw, EINA_FALSE, &more);
}
evas_object_box_remove_all(sd->bx, EINA_FALSE);
- if ((!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) ||
- ( efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) ||
+ if ((!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) ||
+ ( efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) ||
more)
{
EINA_INLIST_FOREACH(sd->items, it)
{
Evas_Coord iw = 0, ih = 0;
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
h = (vh >= mh) ? vh : mh;
else
w = (vw >= mw) ? vw : mw;
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
_items_visibility_fix(obj, sd, &ih, vh, EINA_TRUE, &more);
else
_items_visibility_fix(obj, sd, &iw, vw, EINA_TRUE, &more);
else
evas_object_hide(sd->VIEW(more_item));
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
if (h > vh) _items_size_fit(obj, &h, vh);
if (sd->item_count - sd->separator_count > 0)
}
else
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
h = (vh >= mh) ? vh : mh;
else
w = (vw >= mw) ? vw : mw;
if (sd->transverse_expanded)
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
w = vw;
else
h = vh;
item_list = evas_object_box_children_get(sd->bx);
- if ((!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iy < vy)) ||
- ( efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iw < vw)) ||
+ if ((!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iy < vy)) ||
+ ( efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iw < vw)) ||
search_next)
{
while ((item_list = eina_list_next(item_list)))
_item_shrink_signal_emit(view, sd->shrink_mode);
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
elm_layout_signal_emit(view, "elm,orient,vertical", "elm");
else
elm_layout_signal_emit(view, "elm,orient,horizontal", "elm");
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
if (sd->shrink_mode != ELM_TOOLBAR_SHRINK_EXPAND)
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
evas_object_size_hint_weight_set(view, EVAS_HINT_EXPAND, -1.0);
evas_object_size_hint_align_set
}
else if (sd->shrink_mode == ELM_TOOLBAR_SHRINK_EXPAND)
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
minw = minw_bx + (w - vw);
if (minh_bx <= vh) minh_bx = vh;
}
else
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
minw = minw_bx + (w - vw);
minh = h - vh;
if (sd->transverse_expanded)
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
minw_bx = vw;
else
minh_bx = vh;
elm_widget_theme_object_set
(obj, wd->resize_obj, "toolbar", "base",
elm_widget_style_get(obj));
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
edje_object_signal_emit(wd->resize_obj, "elm,orient,vertical", "elm");
else
edje_object_signal_emit(wd->resize_obj, "elm,orient,horizontal", "elm");
if (!elm_layout_theme_set
(sd->more, "toolbar", "more", elm_widget_style_get(obj)))
CRI("Failed to set layout!");
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
elm_object_signal_emit(sd->more, "elm,orient,vertical", "elm");
else
elm_object_signal_emit(sd->more, "elm,orient,horizontal", "elm");
ELM_TOOLBAR_DATA_GET(WIDGET(item), sd);
evas_object_geometry_get(VIEW(item), &x, &y, &w, &h);
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
evas_object_move(item->proxy, x, ev->cur.canvas.y - (h / 2));
else
evas_object_move(item->proxy, ev->cur.canvas.x - (w / 2), y);
ELM_TOOLBAR_DATA_GET(obj, sd);
- horizontal = efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE);
+ horizontal = efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE);
_els_box_layout
(o, priv, horizontal, sd->homogeneous, efl_ui_mirrored_get(obj));
elm_interface_scrollable_objects_set(obj, edje, priv->hit_rect);
priv->standard_priority = -99999;
- priv->dir = EFL_UI_DIR_HORIZONTAL;
+ priv->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
elm_interface_scrollable_bounce_allow_set
(obj, _elm_config->thumbscroll_bounce_enable, EINA_FALSE);
priv->more = elm_layout_add(obj);
if (!elm_layout_theme_set(priv->more, "toolbar", "more", "default"))
CRI("Failed to set layout!");
- if (!efl_ui_dir_is_horizontal(priv->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(priv->dir, EINA_TRUE))
elm_object_signal_emit(priv->more, "elm,orient,vertical", "elm");
else
elm_object_signal_emit(priv->more, "elm,orient,horizontal", "elm");
evas_object_geometry_get(VIEW(it), &ix, &iy, &iw, &ih);
r = EINA_RECT(ix, iy, iw, ih);
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
//TODO: Enhance it later.
if ((ix < vx) || (ix + iw) > (vx + vw) || (iy + ih) > (vy + vh))
EOLIAN static void
_elm_toolbar_align_set(Eo *obj EINA_UNUSED, Elm_Toolbar_Data *sd, double align)
{
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
{
if (sd->align != align)
evas_object_box_align_set(sd->bx, 0.5, align);
}
EOLIAN static void
-_elm_toolbar_efl_ui_direction_direction_set(Eo *obj, Elm_Toolbar_Data *sd, Efl_Ui_Dir dir)
+_elm_toolbar_efl_ui_layout_orientable_orientation_set(Eo *obj, Elm_Toolbar_Data *sd, Efl_Ui_Layout_Orientation dir)
{
// Adjust direction to be either horizontal or vertical.
- if (efl_ui_dir_is_horizontal(dir, EINA_TRUE))
- dir = EFL_UI_DIR_HORIZONTAL;
+ if (efl_ui_layout_orientation_is_horizontal(dir, EINA_TRUE))
+ dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else
- dir = EFL_UI_DIR_VERTICAL;
+ dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
sd->dir = dir;
- if (!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE))
+ if (!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE))
evas_object_box_align_set(sd->bx, 0.5, sd->align);
else
evas_object_box_align_set(sd->bx, sd->align, 0.5);
_sizing_eval(obj);
}
-EOLIAN static Efl_Ui_Dir
-_elm_toolbar_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Elm_Toolbar_Data *sd)
+EOLIAN static Efl_Ui_Layout_Orientation
+_elm_toolbar_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Elm_Toolbar_Data *sd)
{
return sd->dir;
}
EAPI void
elm_toolbar_horizontal_set(Evas_Object *obj, Eina_Bool horizontal)
{
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
if (horizontal)
- dir = EFL_UI_DIR_HORIZONTAL;
+ dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else
- dir = EFL_UI_DIR_VERTICAL;
+ dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
- efl_ui_direction_set(obj, dir);
+ efl_ui_layout_orientation_set(obj, dir);
}
EAPI Eina_Bool
{
ELM_TOOLBAR_DATA_GET_OR_RETURN_VAL(obj, sd, EINA_FALSE);
- return efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE);
+ return efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE);
}
EOLIAN static unsigned int
void _elm_toolbar_efl_orientation_orientation_set(Eo *obj, Elm_Toolbar_Data *pd, Efl_Orient dir);
-void _elm_toolbar_efl_ui_direction_direction_set(Eo *obj, Elm_Toolbar_Data *pd, Efl_Ui_Dir dir);
+void _elm_toolbar_efl_ui_layout_orientable_orientation_set(Eo *obj, Elm_Toolbar_Data *pd, Efl_Ui_Layout_Orientation dir);
-Efl_Ui_Dir _elm_toolbar_efl_ui_direction_direction_get(const Eo *obj, Elm_Toolbar_Data *pd);
+Efl_Ui_Layout_Orientation _elm_toolbar_efl_ui_layout_orientable_orientation_get(const Eo *obj, Elm_Toolbar_Data *pd);
Eina_Bool _elm_toolbar_efl_ui_widget_focus_state_apply(Eo *obj, Elm_Toolbar_Data *pd, Efl_Ui_Widget_Focus_State current_state, Efl_Ui_Widget_Focus_State *configured_state, Efl_Ui_Widget *redirect);
EFL_OBJECT_OP_FUNC(efl_ui_widget_focus_highlight_geometry_get, _elm_toolbar_efl_ui_widget_focus_highlight_geometry_get),
EFL_OBJECT_OP_FUNC(elm_widget_item_container_focused_item_get, _elm_toolbar_elm_widget_item_container_focused_item_get),
EFL_OBJECT_OP_FUNC(efl_orientation_set, _elm_toolbar_efl_orientation_orientation_set),
- EFL_OBJECT_OP_FUNC(efl_ui_direction_set, _elm_toolbar_efl_ui_direction_direction_set),
- EFL_OBJECT_OP_FUNC(efl_ui_direction_get, _elm_toolbar_efl_ui_direction_direction_get),
+ EFL_OBJECT_OP_FUNC(efl_ui_layout_orientation_set, _elm_toolbar_efl_ui_layout_orientable_orientation_set),
+ EFL_OBJECT_OP_FUNC(efl_ui_layout_orientation_get, _elm_toolbar_efl_ui_layout_orientable_orientation_get),
EFL_OBJECT_OP_FUNC(efl_ui_widget_focus_state_apply, _elm_toolbar_efl_ui_widget_focus_state_apply),
EFL_OBJECT_OP_FUNC(efl_ui_widget_screen_reader, _elm_toolbar_efl_ui_widget_screen_reader),
EFL_OBJECT_OP_FUNC(efl_access_widget_action_elm_actions_get, _elm_toolbar_efl_access_widget_action_elm_actions_get),
NULL
};
-EFL_DEFINE_CLASS(elm_toolbar_class_get, &_elm_toolbar_class_desc, EFL_UI_WIDGET_CLASS, EFL_UI_FOCUS_COMPOSITION_MIXIN, ELM_INTERFACE_SCROLLABLE_MIXIN, EFL_UI_DIRECTION_INTERFACE, EFL_ACCESS_WIDGET_ACTION_MIXIN, EFL_ACCESS_SELECTION_INTERFACE, EFL_ACCESS_OBJECT_MIXIN, EFL_UI_CLICKABLE_MIXIN, EFL_UI_SELECTABLE_INTERFACE, EFL_UI_LEGACY_INTERFACE, ELM_WIDGET_ITEM_CONTAINER_INTERFACE, NULL);
+EFL_DEFINE_CLASS(elm_toolbar_class_get, &_elm_toolbar_class_desc, EFL_UI_WIDGET_CLASS, EFL_UI_FOCUS_COMPOSITION_MIXIN, ELM_INTERFACE_SCROLLABLE_MIXIN, EFL_UI_LAYOUT_ORIENTABLE_INTERFACE, EFL_ACCESS_WIDGET_ACTION_MIXIN, EFL_ACCESS_SELECTION_INTERFACE, EFL_ACCESS_OBJECT_MIXIN, EFL_UI_CLICKABLE_MIXIN, EFL_UI_SELECTABLE_INTERFACE, EFL_UI_LEGACY_INTERFACE, ELM_WIDGET_ITEM_CONTAINER_INTERFACE, NULL);
#include "elm_toolbar_eo.legacy.c"
* small */
Eina_List *omit;
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
int level;
Evas_Coord dx, dy;
Ecore_Timer *delay;
Elm_Object_Select_Mode select_mode;
Ecore_Timer *long_timer;
Ecore_Job *resize_job;
- Efl_Ui_Dir dir;
+ Efl_Ui_Layout_Orientation dir;
Eina_Bool long_press : 1;
Eina_Bool homogeneous : 1;
int i, max_index = (sizeof(hints) / sizeof(Hint));
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2);
- efl_ui_direction_set(layout, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
efl_pack_end(layout, efl_added));
Eo *btn, *btn2, *btn3;
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2);
- efl_ui_direction_set(layout, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
max_index2 = ((sizeof(hints2) / sizeof(Hint)) / 2);
max_index3 = ((sizeof(hints3) / sizeof(Hint)) / 3);
btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2));
btn_geom_assert(&hints3[3][2], efl_gfx_entity_geometry_get(btn3));
- efl_ui_direction_set(layout, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
hints3[3][0].layout_expected = hints3[3][0].layout_size = EINA_SIZE2D(300, 900);
hints3[3][1].layout_expected = hints3[3][1].layout_size = EINA_SIZE2D(300, 900);
hints3[3][2].layout_expected = hints3[3][2].layout_size = EINA_SIZE2D(300, 900);
Eo *btn, *btn2, *btn3;
Eina_Size2D min, user_min;
- efl_ui_direction_set(layout, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 100)),
ck_assert_int_eq(b, 1);
//direction test
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_VERTICAL);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
- efl_ui_direction_set(layout, EFL_UI_DIR_DEFAULT);
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_DEFAULT);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
- efl_ui_direction_set(layout, EFL_UI_DIR_HORIZONTAL);
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
//homogeneous test
ck_assert_int_eq(efl_ui_box_homogeneous_get(layout), 0);
layout = efl_add(EFL_UI_BOX_FLOW_CLASS, win,
efl_gfx_arrangement_content_align_set(efl_added, 0.8, 0.2),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
}
static void
btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2));
btn_geom_assert(&hints3[3][2], efl_gfx_entity_geometry_get(btn3));
- efl_ui_direction_set(layout, EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
hints3[3][0].layout_expected = hints3[3][0].layout_size = EINA_SIZE2D(300, 900);
hints3[3][1].layout_expected = hints3[3][1].layout_size = EINA_SIZE2D(300, 900);
hints3[3][2].layout_expected = hints3[3][2].layout_size = EINA_SIZE2D(300, 900);
layout = efl_add(EFL_UI_BOX_STACK_CLASS, win,
efl_gfx_arrangement_content_align_set(efl_added, 0.8, 0.2),
- efl_ui_direction_set(efl_added, EFL_UI_DIR_VERTICAL));
+ efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
}
static void
int i, max_index = (sizeof(hints) / sizeof(Hint));
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2);
- efl_ui_direction_set(layout, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
efl_pack_table(layout, efl_added, 0, 0, 1, 1));
Eo *btn, *btn2, *btn3;
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2);
- efl_ui_direction_set(layout, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
max_index2 = ((sizeof(hints2) / sizeof(Hint)) / 2);
max_index3 = ((sizeof(hints3) / sizeof(Hint)) / 3);
Eo *btn[9];
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2);
- efl_ui_direction_set(layout, EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
efl_gfx_hint_margin_set(layout, 10, 10, 20, 20);
efl_ui_table_homogeneous_set(layout, 0, 1);
ck_assert_int_eq(b, 1);
//direction test
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_RIGHT);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
- efl_ui_direction_set(layout, EFL_UI_DIR_VERTICAL);
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_VERTICAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
- efl_ui_direction_set(layout, EFL_UI_DIR_RIGHT);
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_RIGHT);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
- efl_ui_direction_set(layout, EFL_UI_DIR_DEFAULT);
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_RIGHT);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_DEFAULT);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
- efl_ui_direction_set(layout, EFL_UI_DIR_HORIZONTAL);
- ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_HORIZONTAL);
+ efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
+ ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
//homogeneous test
efl_ui_table_homogeneous_get(layout, &homogeneoush, &homogeneousv);
projects / platform / upstream / efl.git / commitdiff