enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

Rename Efl.Ui.Direction -> Efl.Ui.Layout_Orientation 

Summary:
This clarifies a bit the whole Orientation vs. Direction confusion, at the
expense of longer names (Image_Orientation vs. Layout_Orientation).
Also, the interfaces are now adjectives (Orientable) and the enums have long
names (*_Orientation).

Pretty big patch, but no functional changes.

Relates to T7863

Test Plan:
Everything builds and passes tests.
Elementary_tests show same behavior, including the "inverted" widgets, which
are the only parts which received a bit of code changes.
Proof:
https://travis-ci.org/Enlightenment/efl/builds/536277282

Reviewers: zmike, bu5hm4n, cedric

Reviewed By: zmike

Subscribers: #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D8946
This commit is contained in:
Xavi Artigas 2019-05-24 12:30:31 -04:00 committed by Mike Blumenkrantz
parent 00851ea53b
commit 38d7d33354
95 changed files with 526 additions and 618 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Makefile_Efl.am
View File

@ -57,8 +57,8 @@ efl_eolian_files = \
lib/efl/interfaces/efl_pack_linear.eo \ lib/efl/interfaces/efl_pack_linear.eo \
lib/efl/interfaces/efl_pack_table.eo \ lib/efl/interfaces/efl_pack_table.eo \
lib/efl/interfaces/efl_ui_i18n.eo \ lib/efl/interfaces/efl_ui_i18n.eo \
lib/efl/interfaces/efl_ui_direction.eo \ lib/efl/interfaces/efl_ui_layout_orientable.eo \
lib/efl/interfaces/efl_ui_direction_readonly.eo \ lib/efl/interfaces/efl_ui_layout_orientable_readonly.eo \
lib/efl/interfaces/efl_ui_drag.eo \ lib/efl/interfaces/efl_ui_drag.eo \
lib/efl/interfaces/efl_ui_range_display.eo \ lib/efl/interfaces/efl_ui_range_display.eo \
lib/efl/interfaces/efl_ui_range_interactive.eo \ lib/efl/interfaces/efl_ui_range_interactive.eo \
@ -136,7 +136,7 @@ lib/efl/interfaces/efl_file.c \
lib/efl/interfaces/efl_ui_format.c \ lib/efl/interfaces/efl_ui_format.c \
lib/efl/interfaces/efl_gfx_color.c \ lib/efl/interfaces/efl_gfx_color.c \
lib/efl/interfaces/efl_text_markup_util.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) $(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 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

6
src/bin/elementary/test_bg.c
View File

@ -338,7 +338,7 @@ test_bg_window(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
efl_ui_win_alpha_set(efl_added, 1)); efl_ui_win_alpha_set(efl_added, 1));
box = efl_add(EFL_UI_BOX_CLASS, 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_weight_set(efl_added, 1, 1), efl_gfx_hint_weight_set(efl_added, 1, 1),
efl_content_set(win, efl_added)); efl_content_set(win, efl_added));
@ -415,7 +415,7 @@ test_bg_scale_type(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
efl_content_set(win, efl_added)); efl_content_set(win, efl_added));
box = efl_add(EFL_UI_BOX_CLASS, win, 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_gfx_hint_weight_set(efl_added, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND),
efl_content_set(win, efl_added)); efl_content_set(win, efl_added));
@ -428,7 +428,7 @@ test_bg_scale_type(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
efl_pack(box, efl_added)); efl_pack(box, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, box, 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_weight_set(efl_added, EFL_GFX_HINT_EXPAND, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE), efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_pack(box, efl_added)); efl_pack(box, efl_added));

4
src/bin/elementary/test_efl_ui_text.c
View File

@ -180,7 +180,7 @@ test_efl_ui_text(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
bx2 = efl_add(EFL_UI_BOX_CLASS, bx); bx2 = efl_add(EFL_UI_BOX_CLASS, bx);
efl_gfx_hint_weight_set(bx2, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND); 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); bt = efl_add(EFL_UI_BUTTON_CLASS, bx2);
efl_text_set(bt, "Sel"); efl_text_set(bt, "Sel");
@ -372,7 +372,7 @@ test_ui_text_item_factory(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
bx2 = efl_add(EFL_UI_BOX_CLASS, bx); bx2 = efl_add(EFL_UI_BOX_CLASS, bx);
efl_gfx_hint_weight_set(bx2, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND); 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); bt = efl_add(EFL_UI_BUTTON_CLASS, bx2);
efl_text_set(bt, "Image"); efl_text_set(bt, "Image");

4
src/bin/elementary/test_evas_mask.c
View File

@ -110,7 +110,7 @@ test_evas_mask(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
efl_ui_win_autodel_set(efl_added, 1)); efl_ui_win_autodel_set(efl_added, 1));
box = efl_add(EFL_UI_BOX_CLASS, win, 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); efl_content_set(win, box);
// FIXME: No API to set background as "tile" :( // FIXME: No API to set background as "tile" :(
@ -151,7 +151,7 @@ test_evas_mask(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
efl_content_set(efl_part(ly, "content"), gl); efl_content_set(efl_part(ly, "content"), gl);
box2 = efl_add(EFL_UI_BOX_CLASS, win, 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_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_pack(box, efl_added)); efl_pack(box, efl_added));

2
src/bin/elementary/test_evas_snapshot.c
View File

@ -176,7 +176,7 @@ test_evas_snapshot(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _radius_set, win)); efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _radius_set, win));
box = efl_add(EFL_UI_BOX_CLASS, 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_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_pack_table(table, efl_added, 0, TABLE_SIZE + 1, TABLE_SIZE, 1)); efl_pack_table(table, efl_added, 0, TABLE_SIZE + 1, TABLE_SIZE, 1));

2
src/bin/elementary/test_events.c
View File

@ -197,7 +197,7 @@ test_events(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
elm_win_autodel_set(win, EINA_TRUE); elm_win_autodel_set(win, EINA_TRUE);
bx = efl_add(EFL_UI_BOX_CLASS, win, 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); efl_content_set(win, bx);
td->win = win; td->win = win;

12
src/bin/elementary/test_gfx_filters.c
View File

@ -339,13 +339,13 @@ test_gfx_filters(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
efl_ui_win_autodel_set(efl_added, 1)); efl_ui_win_autodel_set(efl_added, 1));
box = efl_add(EFL_UI_BOX_CLASS, win, 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); efl_content_set(win, box);
{ {
box2 = efl_add(EFL_UI_BOX_CLASS, win, 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_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_align_set(efl_added, 0.5, 0.0), efl_gfx_hint_align_set(efl_added, 0.5, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE)); efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE));
@ -384,7 +384,7 @@ test_gfx_filters(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
{ {
box2 = efl_add(EFL_UI_BOX_CLASS, win, 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_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE), efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE),
efl_gfx_arrangement_content_padding_set(efl_added, 5, 5, 1), efl_gfx_arrangement_content_padding_set(efl_added, 5, 5, 1),
@ -445,7 +445,7 @@ test_gfx_filters(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
} }
o = split = efl_add(EFL_UI_PANES_CLASS, win, 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_pack(box, split);
{ {
@ -453,7 +453,7 @@ test_gfx_filters(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
efl_content_set(efl_part(split, "first"), flip); efl_content_set(efl_part(split, "first"), flip);
box2 = efl_add(EFL_UI_BOX_STACK_CLASS, win, 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_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE), efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_gfx_arrangement_content_align_set(efl_added, 0.5, 0.5)); efl_gfx_arrangement_content_align_set(efl_added, 0.5, 0.5));
@ -469,7 +469,7 @@ test_gfx_filters(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
efl_pack(box2, o); efl_pack(box2, o);
o = box2 = efl_add(EFL_UI_BOX_STACK_CLASS, win, 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_weight_set(efl_added, 1.0, 0.0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE), efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_TRUE),
efl_gfx_arrangement_content_align_set(efl_added, 0.5, 0.5)); efl_gfx_arrangement_content_align_set(efl_added, 0.5, 0.5));

6
src/bin/elementary/test_part_bg.c
View File

@ -63,7 +63,7 @@ _create_box_contents(Evas_Object *box)
unsigned int i; unsigned int i;
hbox = efl_add(EFL_UI_BOX_CLASS, box, 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_gfx_hint_weight_set(efl_added, 1, 1),
efl_pack_end(box, efl_added)); efl_pack_end(box, efl_added));
@ -86,7 +86,7 @@ _create_box_contents(Evas_Object *box)
if (!content_class[i]) continue; if (!content_class[i]) continue;
hbox = efl_add(EFL_UI_BOX_CLASS, box, 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)); efl_pack_end(box, efl_added));
radio = efl_add(EFL_UI_RADIO_CLASS, hbox, radio = efl_add(EFL_UI_RADIO_CLASS, hbox,
@ -152,7 +152,7 @@ test_part_background(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
efl_content_set(win, efl_added)); efl_content_set(win, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox, 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_gfx_hint_weight_set(efl_added, 1.0, 0.0),
efl_pack_end(vbox, efl_added)); efl_pack_end(vbox, efl_added));

4
src/bin/elementary/test_part_shadow.c
View File

@ -143,7 +143,7 @@ test_part_shadow(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
efl_unref(shadow); efl_unref(shadow);
hbx = efl_add(EFL_UI_BOX_CLASS, win); 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_gfx_hint_weight_set(hbx, EFL_GFX_HINT_EXPAND, 0);
efl_pack(bx, hbx); efl_pack(bx, hbx);
@ -176,7 +176,7 @@ test_part_shadow(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
efl_unref(shadow); efl_unref(shadow);
bt_bx = efl_add(EFL_UI_BOX_CLASS, win); 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_gfx_hint_weight_set(bt_bx, EFL_GFX_HINT_EXPAND, 0);
efl_pack(bx, bt_bx); efl_pack(bx, bt_bx);

2
src/bin/elementary/test_photocam.c
View File

@ -811,7 +811,7 @@ test_image_zoomable_animated(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSE
efl_ui_win_autodel_set(efl_added, EINA_TRUE)); efl_ui_win_autodel_set(efl_added, EINA_TRUE));
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_content_set(win, efl_added));
efl_add(EFL_UI_TEXT_CLASS, bx, efl_add(EFL_UI_TEXT_CLASS, bx,

24
src/bin/elementary/test_ui_box.c
View File

@ -158,7 +158,7 @@ flow_check_cb(void *data, const Efl_Event *event)
efl_del(box); efl_del(box);
box = efl_add(chk ? EFL_UI_BOX_FLOW_CLASS : EFL_UI_BOX_CLASS, win, 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_content_set(parent, box);
efl_key_wref_set(win, "box", box); efl_key_wref_set(win, "box", box);
@ -171,7 +171,7 @@ horiz_check_cb(void *data, const Efl_Event *event)
{ {
Eina_Bool chk = elm_check_selected_get(event->object); Eina_Bool chk = elm_check_selected_get(event->object);
Eo *box = efl_key_wref_get(data, "box"); 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 static void
@ -239,7 +239,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400)); efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400));
vbox = efl_add(EFL_UI_BOX_CLASS, win, 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_arrangement_content_padding_set(vbox, 10, 10, EINA_TRUE);
efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5); efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5);
elm_win_resize_object_add(win, vbox); elm_win_resize_object_add(win, vbox);
@ -254,14 +254,14 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
efl_gfx_entity_visible_set(f, 1); efl_gfx_entity_visible_set(f, 1);
hbox = efl_add(EFL_UI_BOX_CLASS, win, 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_content_set(f, hbox);
efl_gfx_arrangement_content_padding_set(hbox, 10, 0, EINA_TRUE); efl_gfx_arrangement_content_padding_set(hbox, 10, 0, EINA_TRUE);
/* weights radio group */ /* weights radio group */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_pack(hbox, bx); efl_pack(hbox, bx);
@ -315,7 +315,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
/* misc */ /* misc */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1); efl_gfx_hint_weight_set(bx, 0, 1);
@ -362,7 +362,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
/* user min size setter */ /* user min size setter */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1); efl_gfx_hint_weight_set(bx, 0, 1);
@ -389,7 +389,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
/* inner box padding */ /* inner box padding */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1); efl_gfx_hint_weight_set(bx, 0, 1);
@ -416,7 +416,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
/* outer margin */ /* outer margin */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1); efl_gfx_hint_weight_set(bx, 0, 1);
@ -443,7 +443,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
/* Box align */ /* Box align */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1); efl_gfx_hint_weight_set(bx, 1, 1);
@ -483,7 +483,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
/* Button align */ /* Button align */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1); efl_gfx_hint_weight_set(bx, 1, 1);
@ -531,7 +531,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
efl_gfx_entity_visible_set(f, 1); efl_gfx_entity_visible_set(f, 1);
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_key_wref_set(win, "box", bx);
efl_gfx_arrangement_content_padding_set(bx, 10, 10, EINA_TRUE); efl_gfx_arrangement_content_padding_set(bx, 10, 10, EINA_TRUE);
efl_gfx_hint_align_set(bx, 0.5, 0.5); efl_gfx_hint_align_set(bx, 0.5, 0.5);

2
src/bin/elementary/test_ui_button.c
View File

@ -36,7 +36,7 @@ test_ui_button(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
bx = efl_add(EFL_UI_BOX_CLASS, win, bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added), 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 // Text Only Button
efl_add(EFL_UI_BUTTON_CLASS, bx, efl_add(EFL_UI_BUTTON_CLASS, bx,

2
src/bin/elementary/test_ui_datepicker.c
View File

@ -25,7 +25,7 @@ test_ui_datepicker(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
bx = efl_add(EFL_UI_BOX_CLASS, win, bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added), 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_add(EFL_UI_DATEPICKER_CLASS, bx,
efl_ui_datepicker_date_set(efl_added, 1987, 9, 17), efl_ui_datepicker_date_set(efl_added, 1987, 9, 17),

8
src/bin/elementary/test_ui_image.c
View File

@ -353,7 +353,7 @@ test_remote_ui_image(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *event_i
} }
box2 = o = efl_add(EFL_UI_BOX_CLASS, box); 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_weight_set(o, 1.0, 0);
efl_gfx_hint_fill_set(o, EINA_TRUE, EINA_TRUE); efl_gfx_hint_fill_set(o, EINA_TRUE, EINA_TRUE);
@ -554,7 +554,7 @@ test_load_ui_image(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *event_inf
_create_image(win, EINA_FALSE, EINA_FALSE, EINA_FALSE); _create_image(win, EINA_FALSE, EINA_FALSE, EINA_FALSE);
hbox = efl_add(EFL_UI_BOX_CLASS, win); 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_arrangement_content_align_set(hbox, 0, 0.5);
efl_gfx_hint_weight_set(hbox, 1.0, 0.0); efl_gfx_hint_weight_set(hbox, 1.0, 0.0);
efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_FALSE); efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_FALSE);
@ -586,7 +586,7 @@ test_load_ui_image(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *event_inf
efl_pack(box, hbox); efl_pack(box, hbox);
hbox = efl_add(EFL_UI_BOX_CLASS, win); 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_arrangement_content_align_set(hbox, 0.5, 0.5);
efl_gfx_hint_weight_set(hbox, 1.0, 0.0); efl_gfx_hint_weight_set(hbox, 1.0, 0.0);
efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_FALSE), efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_FALSE),
@ -635,7 +635,7 @@ test_ui_image_prescale(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *event_
efl_pack(box, im); efl_pack(box, im);
hbox = efl_add(EFL_UI_BOX_CLASS, win); 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_weight_set(hbox, 1.0, 1.0);
efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_TRUE); efl_gfx_hint_fill_set(hbox, EINA_TRUE, EINA_TRUE);

4
src/bin/elementary/test_ui_pager.c
View File

@ -449,7 +449,7 @@ static void pack_cb(void *data,
in_box1 = efl_add(EFL_UI_BOX_CLASS, box, in_box1 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE), 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, sp1 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box1,
efl_ui_range_min_max_set(efl_added, 0, efl_ui_range_min_max_set(efl_added, 0,
@ -459,7 +459,7 @@ static void pack_cb(void *data,
in_box2 = efl_add(EFL_UI_BOX_CLASS, box, in_box2 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE), 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); sp2 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box2);

6
src/bin/elementary/test_ui_pager_scroll.c
View File

@ -531,7 +531,7 @@ static void side_page_num_cb(void *data,
efl_ui_format_string_set(efl_part(efl_added, "indicator"), "%1.0f"), 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_min_max_set(efl_added, 0, 3),
efl_ui_range_value_set(efl_added, params->side_page_num), 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_weight_set(efl_added, 1, 1),
efl_gfx_hint_align_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, efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
@ -561,7 +561,7 @@ static void pack_cb(void *data,
in_box1 = efl_add(EFL_UI_BOX_CLASS, box, in_box1 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE), 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, sp1 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box1,
efl_ui_range_min_max_set(efl_added, 0, efl_ui_range_min_max_set(efl_added, 0,
@ -571,7 +571,7 @@ static void pack_cb(void *data,
in_box2 = efl_add(EFL_UI_BOX_CLASS, box, in_box2 = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE), 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); sp2 = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box2);

2
src/bin/elementary/test_ui_panes.c
View File

@ -27,7 +27,7 @@ test_panes_minsize(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
); );
panes_h = efl_add(EFL_UI_PANES_CLASS, win, 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_content_set(efl_part(panes, "second"), efl_added)
); );
efl_add(EFL_UI_BUTTON_CLASS, win, efl_add(EFL_UI_BUTTON_CLASS, win,

2
src/bin/elementary/test_ui_progressbar.c
View File

@ -155,7 +155,7 @@ test_ui_progressbar(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *event_inf
btbx = efl_add(EFL_UI_BOX_CLASS, bx, btbx = efl_add(EFL_UI_BOX_CLASS, bx,
efl_pack(bx, efl_added), 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, pd->btn_start = efl_add(EFL_UI_BUTTON_CLASS, btbx,

14
src/bin/elementary/test_ui_relative_layout.c
View File

@ -149,7 +149,7 @@ _setter_add(Eo *vbox, Eo *btn, Options option)
btn_text = ((to == layout) ? "parent" : (char *)efl_text_get(to)); btn_text = ((to == layout) ? "parent" : (char *)efl_text_get(to));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox, 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_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added)); efl_pack(vbox, efl_added));
@ -191,13 +191,13 @@ _button_frame_add(Eo *box, Eo *btn)
efl_pack(box, efl_added)); efl_pack(box, efl_added));
vbox = efl_add(EFL_UI_BOX_CLASS, f, 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_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_gfx_hint_margin_set(efl_added, 2, 2, 2, 2), efl_gfx_hint_margin_set(efl_added, 2, 2, 2, 2),
efl_content_set(f, efl_added)); efl_content_set(f, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox, 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_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added)); efl_pack(vbox, efl_added));
@ -230,7 +230,7 @@ _button_frame_add(Eo *box, Eo *btn)
efl_gfx_hint_align_get(btn, &align_x, &align_y); efl_gfx_hint_align_get(btn, &align_x, &align_y);
hbox = efl_add(EFL_UI_BOX_CLASS, vbox, 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_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added)); efl_pack(vbox, efl_added));
@ -250,7 +250,7 @@ _button_frame_add(Eo *box, Eo *btn)
efl_pack(hbox, efl_added)); efl_pack(hbox, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, vbox, 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_gfx_arrangement_content_padding_set(efl_added, 2, 2, EINA_TRUE),
efl_pack(vbox, efl_added)); efl_pack(vbox, efl_added));
@ -281,7 +281,7 @@ test_ui_relative_layout(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, vo
efl_ui_win_autodel_set(efl_added, EINA_TRUE)); efl_ui_win_autodel_set(efl_added, EINA_TRUE));
vbox = efl_add(EFL_UI_BOX_CLASS, win, 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_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE),
efl_gfx_hint_margin_set(efl_added, 5, 5, 5, 5), efl_gfx_hint_margin_set(efl_added, 5, 5, 5, 5),
efl_content_set(win, efl_added)); efl_content_set(win, efl_added));
@ -293,7 +293,7 @@ test_ui_relative_layout(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, vo
efl_pack(vbox, efl_added)); efl_pack(vbox, efl_added));
hbox = efl_add(EFL_UI_BOX_CLASS, f, 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_gfx_arrangement_content_padding_set(efl_added, 10, 0, EINA_TRUE),
efl_content_set(f, efl_added)); efl_content_set(f, efl_added));

4
src/bin/elementary/test_ui_scroller.c
View File

@ -44,7 +44,7 @@ test_efl_ui_scroller(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
efl_content_set(win, efl_added)); efl_content_set(win, efl_added));
bx = efl_add(EFL_UI_BOX_CLASS, sc, 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_weight_set(efl_added, EVAS_HINT_EXPAND, 0),
efl_gfx_hint_align_set(efl_added, 0.5, 0), efl_gfx_hint_align_set(efl_added, 0.5, 0),
efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE), efl_gfx_hint_fill_set(efl_added, EINA_TRUE, EINA_FALSE),
@ -69,7 +69,7 @@ test_efl_ui_scroller(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
efl_pack(bx, efl_added)); efl_pack(bx, efl_added));
bx2 = efl_add(EFL_UI_BOX_CLASS, sc2, 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)); efl_content_set(sc2, efl_added));
for (i = 0; i < 10; i++) for (i = 0; i < 10; i++)

10
src/bin/elementary/test_ui_slider.c
View File

@ -59,7 +59,7 @@ test_ui_slider(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
efl_add(EFL_UI_SLIDER_CLASS, bx, efl_add(EFL_UI_SLIDER_CLASS, bx,
efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(160, 0)), 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_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_pack(bx, efl_added));
efl_add(EFL_UI_TEXT_CLASS, bx, efl_add(EFL_UI_TEXT_CLASS, bx,
@ -92,7 +92,7 @@ test_ui_slider(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
efl_pack(bx, efl_added)); efl_pack(bx, efl_added));
hbx = efl_add(EFL_UI_BOX_CLASS, bx, 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_pack(bx, efl_added));
efl_add(EFL_UI_SLIDER_CLASS, hbx, efl_add(EFL_UI_SLIDER_CLASS, hbx,
@ -100,14 +100,14 @@ test_ui_slider(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
efl_ui_range_min_max_set(efl_added, 10, 145), efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_range_step_set(efl_added, step), efl_ui_range_step_set(efl_added, step),
efl_ui_range_value_set(efl_added, 70), 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_pack(hbx, efl_added));
efl_add(EFL_UI_SLIDER_CLASS, hbx, efl_add(EFL_UI_SLIDER_CLASS, hbx,
efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(0, 160)), 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_min_max_set(efl_added, 10, 145),
efl_ui_range_step_set(efl_added, step), 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), elm_object_disabled_set(efl_added, EINA_TRUE),
efl_pack(hbx, efl_added)); efl_pack(hbx, efl_added));
@ -116,7 +116,7 @@ test_ui_slider(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
efl_ui_range_min_max_set(efl_added, 10, 145), efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_range_value_set(efl_added, 35), efl_ui_range_value_set(efl_added, 35),
efl_ui_range_step_set(efl_added, step), 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_pack(hbx, efl_added));
efl_add(EFL_UI_TEXT_CLASS, bx, efl_add(EFL_UI_TEXT_CLASS, bx,

6
src/bin/elementary/test_ui_slider_interval.c
View File

@ -82,7 +82,7 @@ test_slider_interval(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
efl_pack(bx, efl_added)); efl_pack(bx, efl_added));
hbx = efl_add(EFL_UI_BOX_CLASS, bx, 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_pack(bx, efl_added));
efl_add(EFL_UI_SLIDER_INTERVAL_CLASS, hbx, efl_add(EFL_UI_SLIDER_INTERVAL_CLASS, hbx,
@ -90,7 +90,7 @@ test_slider_interval(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
efl_ui_range_min_max_set(efl_added, 10, 145), efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_slider_interval_value_set(efl_added, 50, 100), efl_ui_slider_interval_value_set(efl_added, 50, 100),
efl_ui_range_step_set(efl_added, step), 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_pack(hbx, efl_added));
efl_add(EFL_UI_SLIDER_INTERVAL_CLASS, hbx, efl_add(EFL_UI_SLIDER_INTERVAL_CLASS, hbx,
@ -98,7 +98,7 @@ test_slider_interval(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
efl_ui_range_min_max_set(efl_added, 10, 145), efl_ui_range_min_max_set(efl_added, 10, 145),
efl_ui_slider_interval_value_set(efl_added, 50, 100), efl_ui_slider_interval_value_set(efl_added, 50, 100),
efl_ui_range_step_set(efl_added, step), 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), elm_object_disabled_set(efl_added, EINA_TRUE),
efl_pack(hbx, efl_added)); efl_pack(hbx, efl_added));

2
src/bin/elementary/test_ui_spin.c
View File

@ -44,7 +44,7 @@ test_ui_spin(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_i
bx = efl_add(EFL_UI_BOX_CLASS, win, bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added), 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, sp = efl_add(EFL_UI_SPIN_CLASS, bx,
efl_ui_range_min_max_set(efl_added, 0, 10), efl_ui_range_min_max_set(efl_added, 0, 10),

4
src/bin/elementary/test_ui_spin_button.c
View File

@ -35,7 +35,7 @@ test_ui_spin_button(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *
bx = efl_add(EFL_UI_BOX_CLASS, win, bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added), 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_add(EFL_UI_SPIN_BUTTON_CLASS, bx,
efl_ui_range_min_max_set(efl_added, 0, 10), efl_ui_range_min_max_set(efl_added, 0, 10),
@ -58,7 +58,7 @@ test_ui_spin_button(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *
efl_ui_range_value_set(efl_added, 1), efl_ui_range_value_set(efl_added, 1),
efl_ui_spin_button_editable_set(efl_added, EINA_FALSE), efl_ui_spin_button_editable_set(efl_added, EINA_FALSE),
efl_ui_spin_special_value_set(efl_added, array), 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)); efl_pack(bx, efl_added));
eina_array_free(array); eina_array_free(array);

4
src/bin/elementary/test_ui_tab_pager.c
View File

@ -366,7 +366,7 @@ _pack_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
in_box = efl_add(EFL_UI_BOX_CLASS, box, in_box = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE), 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)); efl_pack_end(box, efl_added));
sp = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box, sp = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box,
@ -466,7 +466,7 @@ _unpack_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
in_box = efl_add(EFL_UI_BOX_CLASS, box, in_box = efl_add(EFL_UI_BOX_CLASS, box,
efl_gfx_arrangement_content_padding_set(efl_added, 10, 10, EINA_TRUE), 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)); efl_pack_end(box, efl_added));
sp = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box, sp = efl_add(EFL_UI_SPIN_BUTTON_CLASS, in_box,

26
src/bin/elementary/test_ui_table.c
View File

@ -198,7 +198,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400)); efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400));
vbox = efl_add(EFL_UI_BOX_CLASS, win, 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_arrangement_content_padding_set(vbox, 10, 10, EINA_TRUE);
efl_gfx_hint_weight_set(vbox, 1, 1); efl_gfx_hint_weight_set(vbox, 1, 1);
efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5); efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5);
@ -218,14 +218,14 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
efl_gfx_entity_visible_set(f, 1); efl_gfx_entity_visible_set(f, 1);
hbox = efl_add(EFL_UI_BOX_CLASS, win, 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); elm_object_content_set(f, hbox);
efl_gfx_arrangement_content_padding_set(hbox, 10, 0, EINA_TRUE); efl_gfx_arrangement_content_padding_set(hbox, 10, 0, EINA_TRUE);
/* weights radio group */ /* weights radio group */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_pack(hbox, bx); efl_pack(hbox, bx);
@ -288,7 +288,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
/* min size setter */ /* min size setter */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1); efl_gfx_hint_weight_set(bx, 0, 1);
efl_pack(hbox, bx); efl_pack(hbox, bx);
@ -314,7 +314,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
/* inner box padding */ /* inner box padding */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1); efl_gfx_hint_weight_set(bx, 0, 1);
@ -341,7 +341,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
/* outer margin */ /* outer margin */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 0, 1); efl_gfx_hint_weight_set(bx, 0, 1);
efl_pack(hbox, bx); efl_pack(hbox, bx);
@ -367,7 +367,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
/* button margins */ /* button margins */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1); efl_gfx_hint_weight_set(bx, 1, 1);
@ -394,7 +394,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
/* button1 aligns */ /* button1 aligns */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1); efl_gfx_hint_weight_set(bx, 1, 1);
@ -431,7 +431,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
/* ro info */ /* ro info */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1); efl_gfx_hint_weight_set(bx, 1, 1);
@ -567,7 +567,7 @@ test_ui_table_linear(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400)); efl_gfx_entity_size_set(win, EINA_SIZE2D(600, 400));
vbox = efl_add(EFL_UI_BOX_CLASS, win, 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_arrangement_content_padding_set(vbox, 10, 10, EINA_TRUE);
efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5); efl_gfx_hint_margin_set(vbox, 5, 5, 5, 5);
elm_win_resize_object_add(win, vbox); elm_win_resize_object_add(win, vbox);
@ -587,7 +587,7 @@ test_ui_table_linear(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
efl_gfx_entity_visible_set(f, 1); efl_gfx_entity_visible_set(f, 1);
hbox = efl_add(EFL_UI_BOX_CLASS, win, 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); elm_object_content_set(f, hbox);
efl_gfx_arrangement_content_padding_set(hbox, 5, 0, EINA_TRUE); efl_gfx_arrangement_content_padding_set(hbox, 5, 0, EINA_TRUE);
efl_gfx_entity_visible_set(hbox, 1); efl_gfx_entity_visible_set(hbox, 1);
@ -613,7 +613,7 @@ test_ui_table_linear(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
/* ro info */ /* ro info */
bx = efl_add(EFL_UI_BOX_CLASS, win, 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_align_set(bx, 0, 0.5);
efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE); efl_gfx_hint_fill_set(bx, EINA_FALSE, EINA_TRUE);
efl_gfx_hint_weight_set(bx, 1, 1); efl_gfx_hint_weight_set(bx, 1, 1);
@ -648,7 +648,7 @@ test_ui_table_linear(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
efl_gfx_entity_visible_set(f, 1); efl_gfx_entity_visible_set(f, 1);
efl_pack_table_columns_set(table, 4); 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); efl_gfx_hint_weight_set(table, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_object_content_set(f, table); elm_object_content_set(f, table);
efl_gfx_entity_visible_set(table, 1); efl_gfx_entity_visible_set(table, 1);

2
src/bin/elementary/test_ui_timepicker.c
View File

@ -26,7 +26,7 @@ test_ui_timepicker(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
bx = efl_add(EFL_UI_BOX_CLASS, win, bx = efl_add(EFL_UI_BOX_CLASS, win,
efl_content_set(win, efl_added), 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_add(EFL_UI_TIMEPICKER_CLASS, bx,
efl_ui_timepicker_time_set(efl_added, 11, 35), efl_ui_timepicker_time_set(efl_added, 11, 35),

2
src/bin/elementary/test_win_inline.c
View File

@ -227,7 +227,7 @@ test_win_inline(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *even
evas_object_show(bg); evas_object_show(bg);
box = efl_add(EFL_UI_BOX_CLASS, 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));
elm_win_resize_object_add(win, box); elm_win_resize_object_add(win, box);
win2 = elm_win_add(win, "inlined", ELM_WIN_INLINED_IMAGE); win2 = elm_win_add(win, "inlined", ELM_WIN_INLINED_IMAGE);

6
src/examples/elementary/button_cxx_example_01.cc
View File

@ -27,7 +27,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
win.content_set(box); win.content_set(box);
efl::ui::Box box_initial(instantiate, win); 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_initial.hint_weight_set(EFL_GFX_HINT_EXPAND, 0.0);
box.pack_end(box_initial); box.pack_end(box_initial);
@ -78,7 +78,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
efl::eolian::event_add(efl::ui::Clickable::clicked_event, btn3, btn_options); efl::eolian::event_add(efl::ui::Clickable::clicked_event, btn3, btn_options);
efl::ui::Box box_gap(instantiate, win); 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_gap.hint_weight_set(EFL_GFX_HINT_EXPAND, 0.0);
box.pack_end(box_gap); box.pack_end(box_gap);
@ -174,7 +174,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
up.content_set(icon_up); up.content_set(icon_up);
efl::ui::Box box_inferior(instantiate, win); 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.pack_end(box_inferior);
box_inferior.visible_set(true); box_inferior.visible_set(true);

8
src/examples/elementary/efl_ui_grid_example_1.c
View File

@ -19,10 +19,10 @@ typedef struct _Grid_Event_Data {
} Grid_Event_Data; } Grid_Event_Data;
Eo * 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); 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_weight_set(obj, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
efl_gfx_hint_fill_set(obj, EINA_TRUE, EINA_TRUE); efl_gfx_hint_fill_set(obj, EINA_TRUE, EINA_TRUE);
return obj; return obj;
@ -43,7 +43,7 @@ elm_main(int argc, char **argv)
efl_text_set(efl_added, "Efl.Ui.Grid"), efl_text_set(efl_added, "Efl.Ui.Grid"),
efl_ui_win_autodel_set(efl_added, EINA_TRUE)); 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); elm_win_resize_object_add(win, box);
Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, box); Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, box);
@ -54,7 +54,7 @@ elm_main(int argc, char **argv)
Eina_Bool horiz = 0; Eina_Bool horiz = 0;
// TEST#1 : Create Grid // 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_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_padding_set(grid, 5.0, 5.0, EINA_TRUE);
efl_gfx_arrangement_content_align_set(grid, 0.5, 0.5); efl_gfx_arrangement_content_align_set(grid, 0.5, 0.5);

14
src/examples/elementary/efl_ui_list_example_1.c
View File

@ -114,7 +114,7 @@ elm_main(int argc EINA_UNUSED, char **argv)
efl_gfx_entity_size_set(win, EINA_SIZE2D(400, 800)); efl_gfx_entity_size_set(win, EINA_SIZE2D(400, 800));
wbox = efl_add(EFL_UI_BOX_CLASS, win); 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_weight_set(wbox, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
efl_gfx_hint_fill_set(wbox, EINA_TRUE, EINA_TRUE); efl_gfx_hint_fill_set(wbox, EINA_TRUE, EINA_TRUE);
@ -142,7 +142,7 @@ elm_main(int argc EINA_UNUSED, char **argv)
if (emptystyle) if (emptystyle)
{ {
ibox = efl_add(EFL_UI_BOX_CLASS, item); 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); txt = efl_add(EFL_UI_TEXT_CLASS, ibox);
efl_gfx_hint_weight_set(txt, 0.95, EFL_GFX_HINT_EXPAND); efl_gfx_hint_weight_set(txt, 0.95, EFL_GFX_HINT_EXPAND);
@ -230,7 +230,7 @@ elm_main(int argc EINA_UNUSED, char **argv)
efl_pack_end(wbox, txt); efl_pack_end(wbox, txt);
bbox = efl_add(EFL_UI_BOX_CLASS, wbox); 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); efl_gfx_hint_weight_set(bbox, EFL_GFX_HINT_EXPAND, 0.05);
select_radio = radio = efl_add(EFL_UI_RADIO_CLASS, wbox); select_radio = radio = efl_add(EFL_UI_RADIO_CLASS, wbox);
@ -267,7 +267,7 @@ elm_main(int argc EINA_UNUSED, char **argv)
efl_pack_end(wbox, txt); efl_pack_end(wbox, txt);
priv_d.slider = slider = efl_add(EFL_UI_SLIDER_CLASS, wbox); 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_weight_set(slider, 0.0, 0.05);
efl_gfx_hint_align_set(slider, 0.5, 0.5); efl_gfx_hint_align_set(slider, 0.5, 0.5);
efl_gfx_hint_size_min_set(slider, EINA_SIZE2D(380, 20)); efl_gfx_hint_size_min_set(slider, EINA_SIZE2D(380, 20));
@ -275,11 +275,11 @@ elm_main(int argc EINA_UNUSED, char **argv)
efl_pack_end(wbox, slider); efl_pack_end(wbox, slider);
bbox = efl_add(EFL_UI_BOX_CLASS, wbox); 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); efl_gfx_hint_weight_set(bbox, EFL_GFX_HINT_EXPAND, 0.05);
rbox = efl_add(EFL_UI_BOX_CLASS, bbox); 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); anim_radio = radio = efl_add(EFL_UI_RADIO_CLASS, rbox);
efl_gfx_hint_align_set(radio, 0.5, 0.5); efl_gfx_hint_align_set(radio, 0.5, 0.5);
@ -297,7 +297,7 @@ elm_main(int argc EINA_UNUSED, char **argv)
efl_pack_end(bbox, rbox); efl_pack_end(bbox, rbox);
rbox = efl_add(EFL_UI_BOX_CLASS, bbox); 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); scrl_btn = efl_add(EFL_UI_BUTTON_CLASS, rbox);
efl_text_set(scrl_btn, "Scroll Item"); efl_text_set(scrl_btn, "Scroll Item");

2
src/examples/elementary/radio_cxx_example_01.cc
View File

@ -17,7 +17,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
win.autohide_set(true); win.autohide_set(true);
efl::ui::Box bx(instantiate, win); 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); win.content_set(bx);
efl::ui::Radio radio(instantiate, win); efl::ui::Radio radio(instantiate, win);

4
src/examples/elementary/slider_cxx_example.cc
View File

@ -50,13 +50,13 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
efl::ui::Slider sl5(instantiate, win); efl::ui::Slider sl5(instantiate, win);
sl5.range_min_max_set(0, 100); sl5.range_min_max_set(0, 100);
sl5.range_step_set(1); 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_fill_set(true, false);
sl5.hint_size_min_set({0, 120}); sl5.hint_size_min_set({0, 120});
bx.pack_end(sl5); bx.pack_end(sl5);
efl::ui::Slider sl6(instantiate, win); 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.range_min_max_set(0, 10);
sl6.hint_fill_set(false, true); sl6.hint_fill_set(false, true);
sl6.hint_weight_set(0, EFL_GFX_HINT_EXPAND); sl6.hint_weight_set(0, EFL_GFX_HINT_EXPAND);

12
src/lib/edje/edje_part_box.c
View File

@ -139,23 +139,23 @@ _efl_canvas_layout_part_box_efl_container_content_count(Eo *obj, void *_pd EINA_
return evas_obj_box_count(pd->rp->object); return evas_obj_box_count(pd->rp->object);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_canvas_layout_part_box_efl_ui_direction_direction_get(const Eo *obj, void *_pd EINA_UNUSED) _efl_canvas_layout_part_box_efl_ui_layout_orientable_orientation_get(const Eo *obj, void *_pd EINA_UNUSED)
{ {
PROXY_DATA_GET(obj, pd); PROXY_DATA_GET(obj, pd);
const Edje_Part_Description_Box *desc = const Edje_Part_Description_Box *desc =
(Edje_Part_Description_Box *) pd->rp->chosen_description; (Edje_Part_Description_Box *) pd->rp->chosen_description;
if (!desc || !desc->box.layout) if (!desc || !desc->box.layout)
return EFL_UI_DIR_DEFAULT; return EFL_UI_LAYOUT_ORIENTATION_DEFAULT;
if (!strncmp(desc->box.layout, "vertical", 8)) 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)) 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); 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" #include "efl_canvas_layout_part_box.eo.c"

2
src/lib/edje/edje_part_invalid.c
View File

@ -86,7 +86,7 @@ EDJE_PART_INVALID(Eina_Bool, 0, efl_pack_at, _efl_canvas_layout_part_invalid_efl
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_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(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(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(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(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) 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)

4
src/lib/edje/efl_canvas_layout_part_box.eo
View File

@ -1,5 +1,5 @@
class @beta Efl.Canvas.Layout_Part_Box extends Efl.Canvas.Layout_Part implements Efl.Pack_Linear, 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. [[Represents a Box created as part of a layout.
@ -22,6 +22,6 @@ class @beta Efl.Canvas.Layout_Part_Box extends Efl.Canvas.Layout_Part implements
Efl.Pack_Linear.pack_content_get; Efl.Pack_Linear.pack_content_get;
Efl.Pack_Linear.pack_unpack_at; Efl.Pack_Linear.pack_unpack_at;
Efl.Pack_Linear.pack_index_get; 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.]] }
} }
} }

4
src/lib/edje/efl_canvas_layout_part_invalid.eo
View File

@ -1,5 +1,5 @@
class @beta Efl.Canvas.Layout_Part_Invalid extends Efl.Canvas.Layout_Part implements Efl.Content, 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.Pack_Table, Efl.Text,
Efl.Text_Markup, Efl.Text_Markup_Interactive Efl.Text_Markup, Efl.Text_Markup_Interactive
{ {
@ -58,7 +58,7 @@ class @beta Efl.Canvas.Layout_Part_Invalid extends Efl.Canvas.Layout_Part implem
Efl.Pack_Linear.pack_content_get; Efl.Pack_Linear.pack_content_get;
Efl.Pack_Linear.pack_unpack_at; Efl.Pack_Linear.pack_unpack_at;
Efl.Pack_Linear.pack_index_get; 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.Canvas.Layout_Part_Table
Efl.Pack_Table.pack_table; Efl.Pack_Table.pack_table;
Efl.Pack_Table.table_content_get; Efl.Pack_Table.table_content_get;

4
src/lib/efl/Efl.h
View File

@ -97,8 +97,8 @@ typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;
#include "interfaces/efl_text.eo.h" #include "interfaces/efl_text.eo.h"
#include "interfaces/efl_text_types.eot.h" #include "interfaces/efl_text_types.eot.h"
#include "interfaces/efl_ui_i18n.eo.h" #include "interfaces/efl_ui_i18n.eo.h"
#include "interfaces/efl_ui_direction.eo.h" #include "interfaces/efl_ui_layout_orientable.eo.h"
#include "interfaces/efl_ui_direction_readonly.eo.h" #include "interfaces/efl_ui_layout_orientable_readonly.eo.h"
#include "interfaces/efl_ui_drag.eo.h" #include "interfaces/efl_ui_drag.eo.h"
#include "interfaces/efl_ui_range_display.eo.h" #include "interfaces/efl_ui_range_display.eo.h"
#include "interfaces/efl_ui_range_interactive.eo.h" #include "interfaces/efl_ui_range_interactive.eo.h"

4
src/lib/efl/interfaces/efl_gfx_image_orientable.eo
View File

@ -1,4 +1,4 @@
parse efl_ui_direction; parse efl_ui_layout_orientable;
enum @beta Efl.Gfx.Image_Orientation enum @beta Efl.Gfx.Image_Orientation
{ {
@ -10,7 +10,7 @@ enum @beta Efl.Gfx.Image_Orientation
its roof pointing to the right if the $right orientation is used). its roof pointing to the right if the $right orientation is used).
Flipping values ($flip_horizontal and $flip_vertical) can be additionaly added Flipping values ($flip_horizontal and $flip_vertical) can be additionaly added
to produce a mirroring in each axis. 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 than images and canvases. This enum is used to rotate images, videos and
the like. the like.
]] ]]

2
src/lib/efl/interfaces/efl_interfaces_main.c
View File

@ -61,7 +61,7 @@
#include "interfaces/efl_model.eo.c" #include "interfaces/efl_model.eo.c"
#include "interfaces/efl_interpolator.eo.c" #include "interfaces/efl_interpolator.eo.c"
#include "interfaces/efl_ui_i18n.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_drag.eo.c"
#include "interfaces/efl_ui_range_display.eo.c" #include "interfaces/efl_ui_range_display.eo.c"
#include "interfaces/efl_ui_range_interactive.eo.c" #include "interfaces/efl_ui_range_interactive.eo.c"

48
src/lib/efl/interfaces/efl_ui_direction.eo
View File

@ -1,48 +0,0 @@
// 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.]]
}
}
}
}

17
src/lib/efl/interfaces/efl_ui_direction_readonly.c
View File

@ -1,17 +0,0 @@
#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"

6
src/lib/efl/interfaces/efl_ui_direction_readonly.eo
View File

@ -1,6 +0,0 @@
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]]}
}
}

52
src/lib/efl/interfaces/efl_ui_layout_orientable.eo Normal file
View File

@ -0,0 +1,52 @@
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.]]
}
}
}
}

17
src/lib/efl/interfaces/efl_ui_layout_orientable_readonly.c Normal file
View File

@ -0,0 +1,17 @@
#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"

6
src/lib/efl/interfaces/efl_ui_layout_orientable_readonly.eo Normal file
View File

@ -0,0 +1,6 @@
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.]] }
}
}

6
src/lib/efl/interfaces/meson.build
View File

@ -73,8 +73,8 @@ pub_eo_files = [
'efl_pack_table.eo', 'efl_pack_table.eo',
'efl_gfx_arrangement.eo', 'efl_gfx_arrangement.eo',
'efl_ui_i18n.eo', 'efl_ui_i18n.eo',
'efl_ui_direction.eo', 'efl_ui_layout_orientable.eo',
'efl_ui_direction_readonly.eo', 'efl_ui_layout_orientable_readonly.eo',
'efl_ui_drag.eo', 'efl_ui_drag.eo',
'efl_ui_range_display.eo', 'efl_ui_range_display.eo',
'efl_ui_range_interactive.eo', 'efl_ui_range_interactive.eo',
@ -167,7 +167,7 @@ efl_src += files([
'efl_observer.c', 'efl_observer.c',
'efl_file.c', 'efl_file.c',
'efl_ui_format.c', 'efl_ui_format.c',
'efl_ui_direction_readonly.c', 'efl_ui_layout_orientable_readonly.c',
'efl_text_markup_util.c', 'efl_text_markup_util.c',
]) ])

2
src/lib/elementary/efl_page_indicator_icon.c
View File

@ -147,7 +147,7 @@ _efl_page_indicator_icon_efl_page_indicator_bind(Eo *obj,
if (spd->pager.obj) 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); efl_gfx_arrangement_content_padding_set(spd->idbox, 15, 15, EINA_TRUE);
pd->v = eina_value_float_new(0.0); pd->v = eina_value_float_new(0.0);

24
src/lib/elementary/efl_ui_box.c
View File

@ -183,7 +183,7 @@ _efl_ui_box_efl_object_constructor(Eo *obj, Efl_Ui_Box_Data *pd)
efl_access_object_access_type_set(obj, EFL_ACCESS_TYPE_SKIPPED); efl_access_object_access_type_set(obj, EFL_ACCESS_TYPE_SKIPPED);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_FILLER); 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.h = 0.5;
pd->align.v = 0.5; pd->align.v = 0.5;
@ -372,34 +372,28 @@ _efl_ui_box_efl_container_content_iterate(Eo *obj EINA_UNUSED, Efl_Ui_Box_Data *
} }
EOLIAN static void 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; if (pd->dir == dir) return;
switch (dir) switch (dir)
{ {
case EFL_UI_DIR_RTL: case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
// FIXME: Should be inverted! pd->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
case EFL_UI_DIR_HORIZONTAL:
case EFL_UI_DIR_LTR:
pd->dir = EFL_UI_DIR_HORIZONTAL;
break; break;
case EFL_UI_DIR_UP: case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
// FIXME: Should be inverted! case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
case EFL_UI_DIR_DOWN:
case EFL_UI_DIR_VERTICAL:
case EFL_UI_DIR_DEFAULT:
default: default:
pd->dir = EFL_UI_DIR_VERTICAL; pd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
break; break;
} }
efl_pack_layout_request(obj); efl_pack_layout_request(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_box_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Box_Data *pd) _efl_ui_box_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Box_Data *pd)
{ {
return pd->dir; return pd->dir;
} }

4
src/lib/elementary/efl_ui_box.eo
View File

@ -1,5 +1,5 @@
class @beta Efl.Ui.Box extends Efl.Ui.Widget implements Efl.Pack_Linear, Efl.Pack_Layout, 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. [[The box widget.
@ -35,7 +35,7 @@ class @beta Efl.Ui.Box extends Efl.Ui.Widget implements Efl.Pack_Linear, Efl.Pac
Efl.Gfx.Entity.size { set; } Efl.Gfx.Entity.size { set; }
Efl.Container.content_iterate; Efl.Container.content_iterate;
Efl.Container.content_count; Efl.Container.content_count;
Efl.Ui.Direction.direction { get; set; } Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Pack.pack_clear; Efl.Pack.pack_clear;
Efl.Pack.unpack_all; Efl.Pack.unpack_all;
Efl.Pack.unpack; Efl.Pack.unpack;

2
src/lib/elementary/efl_ui_box_flow.c
View File

@ -70,7 +70,7 @@ _efl_ui_box_flow_efl_pack_layout_layout_update(Eo *obj, Efl_Ui_Box_Flow_Data *pd
Item_Calc *items, *item; Item_Calc *items, *item;
Row_Calc *rows, *row; Row_Calc *rows, *row;
Efl_Ui_Container_Item_Hints *hints, *hint; 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; Eina_Bool c_axis = !axis;
int want[2] = { 0, 0 }; int want[2] = { 0, 0 };
int rc = 0, count, i = 0, id, item_last = 0; int rc = 0, count, i = 0, id, item_last = 0;

2
src/lib/elementary/efl_ui_box_layout.c
View File

@ -35,7 +35,7 @@ _efl_ui_box_custom_layout(Efl_Ui_Box *ui_box, Efl_Ui_Box_Data *pd)
Eina_Inlist *inlist = NULL; Eina_Inlist *inlist = NULL;
Item_Calc *items, *item; Item_Calc *items, *item;
Efl_Ui_Container_Item_Hints *hints, *hint; 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; Eina_Bool r_axis = !axis;
int want[2] = { 0, 0 }; int want[2] = { 0, 0 };
int count, i = 0; int count, i = 0;

2
src/lib/elementary/efl_ui_box_private.h
View File

@ -14,7 +14,7 @@ typedef struct _Efl_Ui_Box_Data Efl_Ui_Box_Data;
struct _Efl_Ui_Box_Data struct _Efl_Ui_Box_Data
{ {
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
Eo *clipper; Eo *clipper;
Eina_List *children; Eina_List *children;

6
src/lib/elementary/efl_ui_datepicker.c
View File

@ -163,21 +163,21 @@ _fields_init(Eo *obj)
efl_ui_range_min_max_set(efl_added, 1970, 2037), efl_ui_range_min_max_set(efl_added, 1970, 2037),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE), efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_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)); 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, pd->month = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_min_max_set(efl_added, 1, 12), efl_ui_range_min_max_set(efl_added, 1, 12),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE), efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_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)); 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, pd->day = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_min_max_set(efl_added, 1, 31), efl_ui_range_min_max_set(efl_added, 1, 31),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE), efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_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)); efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
DATE_GET(); DATE_GET();

44
src/lib/elementary/efl_ui_flip.c
View File

@ -2027,43 +2027,41 @@ _efl_ui_flip_interaction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd)
return sd->intmode; return sd->intmode;
} }
static Efl_Ui_Dir static Efl_Ui_Layout_Orientation
_flip_dir_to_efl_ui_dir(Elm_Flip_Direction dir) _flip_dir_to_efl_ui_dir(Elm_Flip_Direction dir)
{ {
switch (dir) switch (dir)
{ {
case ELM_FLIP_DIRECTION_RIGHT: return EFL_UI_DIR_RIGHT; case ELM_FLIP_DIRECTION_RIGHT: return EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
case ELM_FLIP_DIRECTION_DOWN: return EFL_UI_DIR_DOWN; case ELM_FLIP_DIRECTION_DOWN: return EFL_UI_LAYOUT_ORIENTATION_VERTICAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED;
case ELM_FLIP_DIRECTION_LEFT: return EFL_UI_DIR_LEFT; case ELM_FLIP_DIRECTION_LEFT: return EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL | EFL_UI_LAYOUT_ORIENTATION_INVERTED;
case ELM_FLIP_DIRECTION_UP: return EFL_UI_DIR_UP; case ELM_FLIP_DIRECTION_UP: return EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
} }
ERR("Invalid value for Elm_Flip_Direction: %d", (int) dir); 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 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) switch (dir)
{ {
case EFL_UI_DIR_RIGHT: case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
case EFL_UI_DIR_HORIZONTAL:
return ELM_FLIP_DIRECTION_RIGHT; 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; 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; return ELM_FLIP_DIRECTION_LEFT;
case EFL_UI_DIR_UP: case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
case EFL_UI_DIR_VERTICAL: case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
case EFL_UI_DIR_DEFAULT:
return ELM_FLIP_DIRECTION_UP; 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; return ELM_FLIP_DIRECTION_UP;
} }
EOLIAN static void 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 i = _efl_ui_dir_to_flip_dir(dir);
int area; int area;
@ -2085,13 +2083,13 @@ _efl_ui_flip_interaction_direction_enabled_set(Eo *obj, Efl_Ui_Flip_Data *sd, Ef
} }
EOLIAN static Eina_Bool 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)]; return sd->dir_enabled[_efl_ui_dir_to_flip_dir(dir)];
} }
EOLIAN static void 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); int i = _efl_ui_dir_to_flip_dir(dir);
@ -2189,7 +2187,7 @@ _content_removed(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx_Entity *content)
} }
EOLIAN static double 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); int i = _efl_ui_dir_to_flip_dir(dir);
@ -2299,28 +2297,28 @@ _efl_ui_flip_efl_pack_linear_pack_index_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Dat
EAPI void EAPI void
elm_flip_interaction_direction_hitsize_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, double hitsize) 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); efl_ui_flip_interaction_direction_hitsize_set(obj, uidir, hitsize);
} }
EAPI double EAPI double
elm_flip_interaction_direction_hitsize_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir) 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); return efl_ui_flip_interaction_direction_hitsize_get(obj, uidir);
} }
EOAPI void EOAPI void
elm_flip_interaction_direction_enabled_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, Eina_Bool enabled) 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); efl_ui_flip_interaction_direction_enabled_set(obj, uidir, enabled);
} }
EOAPI Eina_Bool EOAPI Eina_Bool
elm_flip_interaction_direction_enabled_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir) 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); return efl_ui_flip_interaction_direction_enabled_get(obj, uidir);
} }

10
src/lib/elementary/efl_ui_flip.eo
View File

@ -1,4 +1,4 @@
import efl_ui_direction; import efl_ui_layout_orientable;
enum @beta Efl.Ui.Flip_Mode enum @beta Efl.Ui.Flip_Mode
{ {
@ -86,7 +86,7 @@ class @beta Efl.Ui.Flip extends Efl.Ui.Widget implements Efl.Pack_Linear
See also @.interaction.set. See also @.interaction.set.
]] ]]
params { 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.]] @in hitsize: double; [[The amount of that dimension (0.0 to 1.0) to use.]]
} }
} }
@ -94,7 +94,7 @@ class @beta Efl.Ui.Flip extends Efl.Ui.Widget implements Efl.Pack_Linear
[[Get the amount of the flip that is sensitive to interactive flip.]] [[Get the amount of the flip that is sensitive to interactive flip.]]
return: double; [[The size set for that direction.]] return: double; [[The size set for that direction.]]
params { params {
@in dir: Efl.Ui.Dir; [[The direction to check.]] @in dir: Efl.Ui.Layout_Orientation; [[The direction to check.]]
} }
} }
interaction_direction_enabled_set { interaction_direction_enabled_set {
@ -110,7 +110,7 @@ class @beta Efl.Ui.Flip extends Efl.Ui.Widget implements Efl.Pack_Linear
hit area will be created on the opposite edge of the flip. hit area will be created on the opposite edge of the flip.
]] ]]
params { 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.]] @in enabled: bool; [[If that direction is enabled or not.]]
} }
} }
@ -118,7 +118,7 @@ class @beta Efl.Ui.Flip extends Efl.Ui.Widget implements Efl.Pack_Linear
[[Get the enabled state of that flip direction.]] [[Get the enabled state of that flip direction.]]
return: bool; [[If that direction is enabled or not.]] return: bool; [[If that direction is enabled or not.]]
params { params {
@in dir: Efl.Ui.Dir; [[The direction to check.]] @in dir: Efl.Ui.Layout_Orientation; [[The direction to check.]]
} }
} }
go { go {

27
src/lib/elementary/efl_ui_grid.c
View File

@ -64,7 +64,7 @@ _relayout(Eo *obj EINA_UNUSED, Efl_Ui_Grid_Data *pd, Eina_Position2D pan)
Eina_Bool horiz = 0; Eina_Bool horiz = 0;
Eina_Size2D min, max; 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) if (!pd->linemax)
{ {
@ -218,7 +218,7 @@ _item_scroll_internal(Eo *obj,
view = efl_ui_scrollable_viewport_geometry_get(pd->smanager); view = efl_ui_scrollable_viewport_geometry_get(pd->smanager);
vpos = efl_ui_scrollable_content_pos_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.y = view.y;
//ipos.h = ipos.h; //ipos.h = ipos.h;
@ -835,25 +835,18 @@ _efl_ui_grid_efl_container_content_iterate(Eo *obj, Efl_Ui_Grid_Data *pd)
} }
EOLIAN static void 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. //FIXME: Currently only support horizontal and vertical mode.
switch (dir) switch (dir)
{ {
case EFL_UI_DIR_RTL: case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
// FIXME: Should be inverted! pd->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
case EFL_UI_DIR_HORIZONTAL:
case EFL_UI_DIR_LTR:
pd->dir = EFL_UI_DIR_HORIZONTAL;
break; break;
case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
case EFL_UI_DIR_UP: case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
// FIXME: Should be inverted!
case EFL_UI_DIR_DOWN:
case EFL_UI_DIR_VERTICAL:
case EFL_UI_DIR_DEFAULT:
default: default:
pd->dir = EFL_UI_DIR_VERTICAL; pd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
break; break;
} }
@ -861,8 +854,8 @@ _efl_ui_grid_efl_ui_direction_direction_set(Eo *obj EINA_UNUSED, Efl_Ui_Grid_Dat
efl_pack_layout_request(obj); efl_pack_layout_request(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_grid_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Grid_Data *pd) _efl_ui_grid_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Grid_Data *pd)
{ {
return pd->dir; return pd->dir;
} }

4
src/lib/elementary/efl_ui_grid.eo
View File

@ -4,7 +4,7 @@ class @beta Efl.Ui.Grid extends Efl.Ui.Layout_Base implements
Efl.Ui.Scrollable_Interactive, Efl.Ui.Scrollable_Interactive,
Efl.Ui.Scrollbar, Efl.Ui.Scrollbar,
Efl.Pack_Linear, Efl.Pack_Layout, Efl.Pack_Linear, Efl.Pack_Layout,
Efl.Ui.Direction, Efl.Ui.Layout_Orientable,
Efl.Ui.Selectable, Efl.Ui.Selectable,
Efl.Ui.Multi_Selectable, Efl.Ui.Multi_Selectable,
Efl.Gfx.Arrangement Efl.Gfx.Arrangement
@ -60,7 +60,7 @@ class @beta Efl.Ui.Grid extends Efl.Ui.Layout_Base implements
Efl.Container.content_iterate; Efl.Container.content_iterate;
Efl.Container.content_count; Efl.Container.content_count;
Efl.Ui.Direction.direction { get; set; } Efl.Ui.Layout_Orientable.orientation { get; set; }
//Efl.Ui.Widget //Efl.Ui.Widget
Efl.Ui.Widget.theme_apply; Efl.Ui.Widget.theme_apply;

2
src/lib/elementary/efl_ui_grid_private.h
View File

@ -12,7 +12,7 @@ typedef struct _Efl_Ui_Grid_Data
Eo *smanager; /* Scroll Manager for support scroll with pan */ Eo *smanager; /* Scroll Manager for support scroll with pan */
Eina_Rect geo; Eina_Rect geo;
Eina_Position2D pre_pos; Eina_Position2D pre_pos;
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
struct { struct {
Efl_Ui_Grid_Item *item; /* Scroll target item */ Efl_Ui_Grid_Item *item; /* Scroll target item */

8
src/lib/elementary/efl_ui_layout_pack.c
View File

@ -203,12 +203,12 @@ _efl_ui_layout_part_box_efl_pack_linear_pack_index_get(Eo *obj EINA_UNUSED, Efl_
return efl_pack_index_get(pack, subobj); return efl_pack_index_get(pack, subobj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_layout_part_box_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Layout_Box_Data *pd) _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));
} }

4
src/lib/elementary/efl_ui_layout_part_box.eo
View File

@ -1,5 +1,5 @@
class @beta Efl.Ui.Layout_Part_Box extends Efl.Object implements Efl.Pack_Linear, class @beta Efl.Ui.Layout_Part_Box extends Efl.Object implements Efl.Pack_Linear,
Efl.Ui.Direction_Readonly Efl.Ui.Layout_Orientable_Readonly
{ {
[[Represents a Box created as part of a layout. [[Represents a Box created as part of a layout.
@ -22,7 +22,7 @@ class @beta Efl.Ui.Layout_Part_Box extends Efl.Object implements Efl.Pack_Linear
Efl.Object.destructor; Efl.Object.destructor;
Efl.Container.content_iterate; Efl.Container.content_iterate;
Efl.Container.content_count; Efl.Container.content_count;
Efl.Ui.Direction.direction { get; } Efl.Ui.Layout_Orientable.orientation { get; }
Efl.Pack.pack_clear; Efl.Pack.pack_clear;
Efl.Pack.unpack_all; Efl.Pack.unpack_all;
Efl.Pack.unpack; Efl.Pack.unpack;

21
src/lib/elementary/efl_ui_list.c
View File

@ -438,7 +438,7 @@ _efl_ui_list_efl_object_finalize(Eo *obj,
edje_object_part_swallow(wd->resize_obj, "efl.content", pd->pan); edje_object_part_swallow(wd->resize_obj, "efl.content", pd->pan);
pd->box = efl_add(EFL_UI_BOX_CLASS, obj, 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_ui_mirrored_set(pd->box, efl_ui_mirrored_get(obj));
efl_content_set(pd->pan, pd->box); efl_content_set(pd->pan, pd->box);
@ -574,24 +574,17 @@ _efl_ui_list_efl_container_content_iterate(Eo *obj EINA_UNUSED, Efl_Ui_List_Data
/* FIXME: Direction is not supported yet in the list /* FIXME: Direction is not supported yet in the list
EOLIAN static void 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) switch (dir)
{ {
case EFL_UI_DIR_RTL: case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL:
// FIXME: Should be inverted! pd->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
case EFL_UI_DIR_HORIZONTAL:
case EFL_UI_DIR_LTR:
pd->dir = EFL_UI_DIR_HORIZONTAL;
break; break;
case EFL_UI_LAYOUT_ORIENTATION_VERTICAL:
case EFL_UI_DIR_UP: case EFL_UI_LAYOUT_ORIENTATION_DEFAULT:
// FIXME: Should be inverted!
case EFL_UI_DIR_DOWN:
case EFL_UI_DIR_VERTICAL:
case EFL_UI_DIR_DEFAULT:
default: default:
pd->dir = EFL_UI_DIR_VERTICAL; pd->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
break; break;
} }

2
src/lib/elementary/efl_ui_list.eo
View File

@ -51,7 +51,7 @@ class @beta Efl.Ui.List extends Efl.Ui.Layout_Base implements
Efl.Container.content_iterate; Efl.Container.content_iterate;
Efl.Container.content_count; 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
Efl.Ui.Widget.theme_apply; Efl.Ui.Widget.theme_apply;

50
src/lib/elementary/efl_ui_panes.c
View File

@ -103,7 +103,7 @@ _efl_ui_panes_theme_group_get(Evas_Object *obj, Efl_Ui_Panes_Data *sd)
} }
} }
if (sd->dir == EFL_UI_DIR_HORIZONTAL) if (sd->dir == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
eina_strbuf_append(new_group, "horizontal"); eina_strbuf_append(new_group, "horizontal");
else else
eina_strbuf_append(new_group, "vertical"); eina_strbuf_append(new_group, "vertical");
@ -238,7 +238,7 @@ _efl_ui_panes_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Panes_Data *sd)
sd->second_min = efl_gfx_hint_size_min_get(second_content); 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.w = MAX(sd->first_min.w, sd->second_min.w);
min.h = sd->first_min.h + sd->second_min.h; min.h = sd->first_min.h + sd->second_min.h;
@ -267,7 +267,7 @@ _set_min_size_new(void *data)
evas_object_geometry_get(wd->resize_obj, NULL, NULL, &w, &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) if (first_min.h + second_min.h > h)
{ {
@ -331,7 +331,7 @@ _set_min_size(void *data)
sizer = sizer / sum; sizer = sizer / sum;
sizel = sizel / 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 edje_object_part_drag_value_set
(wd->resize_obj, "right_constraint", 0.0, (1 - sizer)); (wd->resize_obj, "right_constraint", 0.0, (1 - sizer));
@ -357,7 +357,7 @@ _update_fixed_sides(void *data)
if (sd->right_min_size_is_relative) 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); sd->right_min_size = (int)(h * sd->right_min_relative_size);
else else
sd->right_min_size =(int)(w * sd->right_min_relative_size); sd->right_min_size =(int)(w * sd->right_min_relative_size);
@ -365,15 +365,15 @@ _update_fixed_sides(void *data)
else else
{ {
sd->right_min_relative_size = 0; 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; 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; sd->right_min_relative_size = sd->right_min_size / (double)w;
} }
if(sd->left_min_size_is_relative) 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); sd->left_min_size = (int)(h * sd->left_min_relative_size);
else else
sd->left_min_size = (int)(w * sd->left_min_relative_size); sd->left_min_size = (int)(w * sd->left_min_relative_size);
@ -381,9 +381,9 @@ _update_fixed_sides(void *data)
else else
{ {
sd->left_min_relative_size = 0; 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; 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; sd->left_min_relative_size = sd->left_min_size / (double)w;
} }
@ -445,7 +445,7 @@ _efl_ui_panes_efl_canvas_group_group_add(Eo *obj, Efl_Ui_Panes_Data *_pd EINA_UN
(wd->resize_obj, EVAS_CALLBACK_RESIZE, (wd->resize_obj, EVAS_CALLBACK_RESIZE,
_on_resize, obj); _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->right_min_size_is_relative = EINA_TRUE;
sd->left_min_size_is_relative = EINA_TRUE; sd->left_min_size_is_relative = EINA_TRUE;
sd->right_min_size = 0; sd->right_min_size = 0;
@ -511,7 +511,7 @@ _efl_ui_panes_split_ratio_get(const Eo *obj, Efl_Ui_Panes_Data *sd)
else else
edje_object_part_drag_value_get(wd->resize_obj, "efl.bar", &w, &h); 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; return h;
else return w; else return w;
} }
@ -524,7 +524,7 @@ _efl_ui_panes_split_ratio_set(Eo *obj, Efl_Ui_Panes_Data *sd, double ratio)
if (ratio < 0.0) ratio = 0.0; if (ratio < 0.0) ratio = 0.0;
else if (ratio > 1.0) ratio = 1.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)) if (elm_widget_is_legacy(obj))
edje_object_part_drag_value_set(wd->resize_obj, "elm.bar", 0.0, ratio); edje_object_part_drag_value_set(wd->resize_obj, "elm.bar", 0.0, ratio);
@ -541,13 +541,13 @@ _efl_ui_panes_split_ratio_set(Eo *obj, Efl_Ui_Panes_Data *sd, double ratio)
} }
EOLIAN static void 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); double size = elm_panes_content_left_size_get(obj);
if (efl_ui_dir_is_horizontal(dir, EINA_FALSE)) if (efl_ui_layout_orientation_is_horizontal(dir, EINA_FALSE))
dir = EFL_UI_DIR_HORIZONTAL; dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else else
dir = EFL_UI_DIR_VERTICAL; dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
sd->dir = dir; sd->dir = dir;
efl_ui_widget_theme_apply(obj); efl_ui_widget_theme_apply(obj);
@ -557,8 +557,8 @@ _efl_ui_panes_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Panes_Data *sd, Efl
elm_panes_content_left_size_set(obj, size); elm_panes_content_left_size_set(obj, size);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_panes_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Panes_Data *sd) _efl_ui_panes_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Panes_Data *sd)
{ {
return sd->dir; return sd->dir;
} }
@ -834,14 +834,14 @@ elm_panes_horizontal_set(Evas_Object *obj, Eina_Bool horizontal)
{ {
EFL_UI_PANES_CHECK(obj); EFL_UI_PANES_CHECK(obj);
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
if (horizontal) if (horizontal)
dir = EFL_UI_DIR_HORIZONTAL; dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else 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 EAPI Eina_Bool
@ -849,9 +849,9 @@ elm_panes_horizontal_get(const Evas_Object *obj)
{ {
EFL_UI_PANES_CHECK(obj) EINA_FALSE; 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_TRUE;
return EINA_FALSE; return EINA_FALSE;

4
src/lib/elementary/efl_ui_panes.eo
View File

@ -1,4 +1,4 @@
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 Efl.Ui.Clickable
{ {
[[Elementary panes class]] [[Elementary panes class]]
@ -48,7 +48,7 @@ class @beta Efl.Ui.Panes extends Efl.Ui.Layout_Base implements Efl.Ui.Direction,
implements { implements {
Efl.Object.constructor; Efl.Object.constructor;
Efl.Ui.Widget.theme_apply; 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; Efl.Part.part_get;
} }
events { events {

26
src/lib/elementary/efl_ui_panes_private.h
View File

@ -34,20 +34,20 @@ struct _Efl_Ui_Panes_Data
Eina_Bool move; Eina_Bool move;
} move; } move;
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
double left_min_relative_size; double left_min_relative_size;
double right_min_relative_size; double right_min_relative_size;
Eina_Size2D first_min, second_min; Eina_Size2D first_min, second_min;
double first_min_split_ratio, second_min_split_ratio; double first_min_split_ratio, second_min_split_ratio;
Evas_Coord left_min_size; Evas_Coord left_min_size;
Evas_Coord right_min_size; Evas_Coord right_min_size;
Eina_Bool double_clicked : 1; Eina_Bool double_clicked : 1;
Eina_Bool fixed : 1; Eina_Bool fixed : 1;
Eina_Bool left_min_size_is_relative : 1; Eina_Bool left_min_size_is_relative : 1;
Eina_Bool right_min_size_is_relative : 1; Eina_Bool right_min_size_is_relative : 1;
Eina_Bool first_hint_min_allow : 1; Eina_Bool first_hint_min_allow : 1;
Eina_Bool second_hint_min_allow : 1; Eina_Bool second_hint_min_allow : 1;
}; };
/** /**

67
src/lib/elementary/efl_ui_progressbar.c
View File

@ -62,37 +62,9 @@ _progress_status_free(Efl_Ui_Progress_Status *ps)
} }
static inline Eina_Bool 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); return efl_ui_layout_orientation_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;
}
} }
static void static void
@ -133,7 +105,6 @@ _units_set(Evas_Object *obj)
static void static void
_val_set(Evas_Object *obj) _val_set(Evas_Object *obj)
{ {
Eina_Bool rtl;
double pos; double pos;
Efl_Ui_Progress_Status *ps; Efl_Ui_Progress_Status *ps;
Eina_List *l; Eina_List *l;
@ -141,8 +112,6 @@ _val_set(Evas_Object *obj)
EFL_UI_PROGRESSBAR_DATA_GET(obj, sd); EFL_UI_PROGRESSBAR_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd); ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
rtl = efl_ui_mirrored_get(obj);
EINA_LIST_FOREACH(sd->progress_status, l, ps) EINA_LIST_FOREACH(sd->progress_status, l, ps)
{ {
if (EINA_DBL_EQ(ps->val_max, ps->val_min)) if (EINA_DBL_EQ(ps->val_max, ps->val_min))
@ -152,9 +121,7 @@ _val_set(Evas_Object *obj)
} }
pos = (ps->val - ps->val_min)/(ps->val_max - ps->val_min); pos = (ps->val - ps->val_min)/(ps->val_max - ps->val_min);
if ((!rtl && _is_inverted(sd->dir)) || if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
(rtl && ((sd->dir == EFL_UI_DIR_UP) ||
(sd->dir == EFL_UI_DIR_RIGHT))))
pos = MAX_RATIO_LVL - pos; pos = MAX_RATIO_LVL - pos;
edje_object_part_drag_value_set edje_object_part_drag_value_set
@ -287,14 +254,14 @@ _efl_ui_progressbar_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Progressbar_Data *
if (elm_widget_is_legacy(obj)) 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"); elm_layout_signal_emit(obj, "elm,state,inverted,on", "elm");
else else
elm_layout_signal_emit(obj, "elm,state,inverted,off", "elm"); elm_layout_signal_emit(obj, "elm,state,inverted,off", "elm");
} }
else 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"); elm_layout_signal_emit(obj, "efl,state,inverted,on", "efl");
else else
elm_layout_signal_emit(obj, "efl,state,inverted,off", "efl"); elm_layout_signal_emit(obj, "efl,state,inverted,off", "efl");
@ -360,7 +327,7 @@ _efl_ui_progressbar_efl_canvas_group_group_add(Eo *obj, Efl_Ui_Progressbar_Data
elm_widget_theme_klass_set(obj, "progressbar"); elm_widget_theme_klass_set(obj, "progressbar");
efl_canvas_group_add(efl_super(obj, MY_CLASS)); 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 = MIN_RATIO_LVL;
priv->val_max = 1.0; priv->val_max = 1.0;
group = _efl_ui_progressbar_theme_group_get(obj, priv); group = _efl_ui_progressbar_theme_group_get(obj, priv);
@ -447,7 +414,7 @@ _efl_ui_progressbar_pulse_mode_get(const Eo *obj EINA_UNUSED, Efl_Ui_Progressbar
} }
EOLIAN static void 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; if (sd->dir == dir) return;
@ -456,8 +423,8 @@ _efl_ui_progressbar_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Progressbar_D
efl_ui_widget_theme_apply(obj); efl_ui_widget_theme_apply(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_progressbar_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Progressbar_Data *sd) _efl_ui_progressbar_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Progressbar_Data *sd)
{ {
return sd->dir; return sd->dir;
} }
@ -934,12 +901,13 @@ elm_progressbar_horizontal_get(const Evas_Object *obj)
EAPI void EAPI void
elm_progressbar_inverted_set(Evas_Object *obj, Eina_Bool inverted) 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); 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 EAPI Eina_Bool
@ -947,18 +915,19 @@ elm_progressbar_inverted_get(const Evas_Object *obj)
{ {
EFL_UI_PROGRESSBAR_DATA_GET_OR_RETURN(obj, sd, EINA_FALSE); 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 EAPI void
elm_progressbar_horizontal_set(Evas_Object *obj, Eina_Bool horizontal) 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); 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 typedef struct

4
src/lib/elementary/efl_ui_progressbar.eo
View File

@ -1,5 +1,5 @@
class @beta Efl.Ui.Progressbar extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Display, Efl.Ui.Format, 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 Efl.Text, Efl.Content, Efl.Text_Markup
{ {
[[Elementary progressbar class]] [[Elementary progressbar class]]
@ -47,7 +47,7 @@ class @beta Efl.Ui.Progressbar extends Efl.Ui.Layout_Base implements Efl.Ui.Rang
Efl.Ui.Widget.theme_apply; Efl.Ui.Widget.theme_apply;
Efl.Ui.Range_Display.range_value { get; set; } Efl.Ui.Range_Display.range_value { get; set; }
Efl.Ui.Range_Display.range_min_max {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.Ui.Format.format_cb { set; }
Efl.Part.part_get; Efl.Part.part_get;
Efl.Access.Value.value_and_text { get; } Efl.Access.Value.value_and_text { get; }

2
src/lib/elementary/efl_ui_progressbar_private.h
View File

@ -43,7 +43,7 @@ struct _Efl_Ui_Progressbar_Data
void *format_cb_data; void *format_cb_data;
Eina_Strbuf *format_strbuf; 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 : 1; /**< Whether object is put in the pulsing mode */
Eina_Bool pulse_state : 1; /**< To start the pulsing animation, otherwise to stop it */ Eina_Bool pulse_state : 1; /**< To start the pulsing animation, otherwise to stop it */

53
src/lib/elementary/efl_ui_slider.c
View File

@ -43,24 +43,14 @@ _delay_change(void *data)
} }
static inline Eina_Bool 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); return efl_ui_layout_orientation_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;
} }
static void static void
_efl_ui_slider_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Data *sd, Eina_Bool user_event) _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; double posx = 0.0, posy = 0.0, pos = 0.0, val;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd); ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
@ -74,10 +64,7 @@ _efl_ui_slider_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Data *sd, Eina_Bool us
if (_is_horizontal(sd->dir)) pos = posx; if (_is_horizontal(sd->dir)) pos = posx;
else pos = posy; else pos = posy;
rtl = efl_ui_mirrored_get(obj); if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
if ((!rtl && _is_inverted(sd->dir)) ||
(rtl && ((sd->dir == EFL_UI_DIR_UP) ||
(sd->dir == EFL_UI_DIR_RIGHT))))
{ {
pos = 1.0 - pos; pos = 1.0 - pos;
} }
@ -102,7 +89,6 @@ _efl_ui_slider_val_set(Evas_Object *obj, Efl_Ui_Slider_Data *sd)
{ {
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd); ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Eina_Bool rtl;
double pos; double pos;
if (sd->val_max > sd->val_min) if (sd->val_max > sd->val_min)
@ -118,10 +104,7 @@ _efl_ui_slider_val_set(Evas_Object *obj, Efl_Ui_Slider_Data *sd)
else if (pos > 1.0) else if (pos > 1.0)
pos = 1.0; pos = 1.0;
rtl = efl_ui_mirrored_get(obj); if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
if ((!rtl && _is_inverted(sd->dir)) ||
(rtl && ((sd->dir == EFL_UI_DIR_UP) ||
(sd->dir == EFL_UI_DIR_RIGHT))))
{ {
pos = 1.0 - pos; pos = 1.0 - pos;
} }
@ -226,7 +209,7 @@ _drag_up(void *data,
EFL_UI_SLIDER_DATA_GET(data, sd); EFL_UI_SLIDER_DATA_GET(data, sd);
step = sd->step; 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); ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
if (elm_widget_is_legacy(obj)) if (elm_widget_is_legacy(obj))
@ -248,7 +231,7 @@ _drag_down(void *data,
EFL_UI_SLIDER_DATA_GET(data, sd); EFL_UI_SLIDER_DATA_GET(data, sd);
step = -sd->step; 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); ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
if (elm_widget_is_legacy(obj)) if (elm_widget_is_legacy(obj))
@ -269,7 +252,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (!_is_horizontal(sd->dir)) if (!_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (!_is_inverted(sd->dir)) if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL); _drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL); else _drag_up(obj, NULL, NULL, NULL);
} }
@ -277,7 +260,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (!_is_horizontal(sd->dir)) if (!_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (!_is_inverted(sd->dir)) if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL); _drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL); else _drag_down(obj, NULL, NULL, NULL);
} }
@ -285,7 +268,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (_is_horizontal(sd->dir)) if (_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (_is_inverted(sd->dir)) if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL); _drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL); else _drag_down(obj, NULL, NULL, NULL);
} }
@ -293,7 +276,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (_is_horizontal(sd->dir)) if (_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (_is_inverted(sd->dir)) if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL); _drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL); else _drag_up(obj, NULL, NULL, NULL);
} }
@ -354,14 +337,14 @@ _efl_ui_slider_efl_ui_widget_on_access_activate(Eo *obj, Efl_Ui_Slider_Data *sd,
if ((act == EFL_UI_ACTIVATE_UP) || if ((act == EFL_UI_ACTIVATE_UP) ||
(act == EFL_UI_ACTIVATE_RIGHT)) (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); _drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL); else _drag_down(obj, NULL, NULL, NULL);
} }
else if ((act == EFL_UI_ACTIVATE_DOWN) || else if ((act == EFL_UI_ACTIVATE_DOWN) ||
(act == EFL_UI_ACTIVATE_LEFT)) (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); _drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL); else _drag_up(obj, NULL, NULL, NULL);
} }
@ -442,14 +425,14 @@ _efl_ui_slider_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Slider_Data *sd)
if (elm_widget_is_legacy(obj)) 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"); efl_layout_signal_emit(obj, "elm,state,inverted,on", "elm");
else else
efl_layout_signal_emit(obj, "elm,state,inverted,off", "elm"); efl_layout_signal_emit(obj, "elm,state,inverted,off", "elm");
} }
else 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"); efl_layout_signal_emit(obj, "efl,state,inverted,on", "efl");
else else
efl_layout_signal_emit(obj, "efl,state,inverted,off", "efl"); efl_layout_signal_emit(obj, "efl,state,inverted,off", "efl");
@ -665,7 +648,7 @@ _efl_ui_slider_efl_object_constructor(Eo *obj, Efl_Ui_Slider_Data *priv)
free(group); free(group);
priv->dir = EFL_UI_DIR_RIGHT; priv->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
priv->val_max = 1.0; priv->val_max = 1.0;
priv->step = SLIDER_STEP; priv->step = SLIDER_STEP;
@ -721,15 +704,15 @@ _efl_ui_slider_efl_object_destructor(Eo *obj,
} }
EOLIAN static void 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; sd->dir = dir;
efl_ui_widget_theme_apply(obj); efl_ui_widget_theme_apply(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_slider_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Data *sd) _efl_ui_slider_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Data *sd)
{ {
return sd->dir; return sd->dir;
} }

4
src/lib/elementary/efl_ui_slider.eo
View File

@ -1,4 +1,4 @@
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.Value,
Efl.Access.Widget.Action Efl.Access.Widget.Action
{ {
@ -13,7 +13,7 @@ class @beta Efl.Ui.Slider extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Int
Efl.Ui.Range_Display.range_value { get; set; } Efl.Ui.Range_Display.range_value { get; set; }
Efl.Ui.Range_Display.range_min_max {get; set; } Efl.Ui.Range_Display.range_min_max {get; set; }
Efl.Ui.Range_Interactive.range_step { 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.value_and_text { get; set; }
Efl.Access.Value.range { get; } Efl.Access.Value.range { get; }
Efl.Access.Value.increment { get; } Efl.Access.Value.increment { get; }

6
src/lib/elementary/efl_ui_slider_interval.c
View File

@ -45,7 +45,7 @@ _efl_ui_slider_interval_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
else else
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable.slider"), efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable.slider"),
&posx, &posy); &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; else pos = posy;
if (elm_widget_is_legacy(obj)) if (elm_widget_is_legacy(obj))
@ -54,7 +54,7 @@ _efl_ui_slider_interval_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
else else
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable2.slider"), efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable2.slider"),
&posx2, &posy2); &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; else pos2 = posy2;
val = (pos * (sd->val_max - sd->val_min)) + sd->val_min; val = (pos * (sd->val_max - sd->val_min)) + sd->val_min;
@ -171,7 +171,7 @@ _efl_ui_slider_interval_down_knob(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
&posx2, &posy2); &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); diff1 = fabs(button_x - posx);
diff2 = fabs(button_x - posx2); diff2 = fabs(button_x - posx2);

14
src/lib/elementary/efl_ui_slider_private.h
View File

@ -6,16 +6,16 @@
typedef struct _Efl_Ui_Slider_Data Efl_Ui_Slider_Data; typedef struct _Efl_Ui_Slider_Data Efl_Ui_Slider_Data;
struct _Efl_Ui_Slider_Data struct _Efl_Ui_Slider_Data
{ {
Evas_Object *spacer; Evas_Object *spacer;
Ecore_Timer *delay; Ecore_Timer *delay;
double val, val_min, val_max, step; double val, val_min, val_max, step;
Evas_Coord downx, downy; Evas_Coord downx, downy;
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
Eina_Bool spacer_down : 1; Eina_Bool spacer_down : 1;
Eina_Bool frozen : 1; Eina_Bool frozen : 1;
}; };
/** /**

8
src/lib/elementary/efl_ui_spin_button.c
View File

@ -779,7 +779,7 @@ _efl_ui_spin_button_theme_group_get(Evas_Object *obj, Efl_Ui_Spin_Button_Data *s
} }
} }
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"); eina_strbuf_append(new_group, "horizontal");
else else
eina_strbuf_append(new_group, "vertical"); eina_strbuf_append(new_group, "vertical");
@ -885,7 +885,7 @@ _efl_ui_spin_button_efl_object_constructor(Eo *obj, Efl_Ui_Spin_Button_Data *sd)
} }
EOLIAN static void 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; if (sd->dir == dir) return;
@ -894,8 +894,8 @@ _efl_ui_spin_button_efl_ui_direction_direction_set(Eo *obj, Efl_Ui_Spin_Button_D
efl_ui_widget_theme_apply(obj); efl_ui_widget_theme_apply(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_spin_button_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd) _efl_ui_spin_button_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd)
{ {
return sd->dir; return sd->dir;
} }

4
src/lib/elementary/efl_ui_spin_button.eo
View File

@ -1,4 +1,4 @@
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 Efl.Access.Widget.Action
{ {
[[A Button Spin. [[A Button Spin.
@ -66,7 +66,7 @@ class @beta Efl.Ui.Spin_Button extends Efl.Ui.Spin implements Efl.Ui.Focus.Compo
Efl.Ui.Widget.widget_input_event_handler; Efl.Ui.Widget.widget_input_event_handler;
Efl.Ui.Focus.Object.on_focus_update; Efl.Ui.Focus.Object.on_focus_update;
Efl.Ui.Range_Display.range_value { set; } 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.Object.i18n_name { get; }
Efl.Access.Value.value_and_text { get; set; } Efl.Access.Value.value_and_text { get; set; }
Efl.Access.Value.range { get; } Efl.Access.Value.range { get; }

2
src/lib/elementary/efl_ui_spin_button_private.h
View File

@ -10,7 +10,7 @@ struct _Efl_Ui_Spin_Button_Data
Ecore_Timer *spin_timer; /**< a timer for a repeated spinner value change on mouse down */ 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 longress timeout, Ecore_Timer *longpress_timer; /**< a timer to detect long press. After longress timeout,
start continuous change of values until mouse up */ 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_visible : 1;
Eina_Bool entry_reactivate : 1; Eina_Bool entry_reactivate : 1;

4
src/lib/elementary/efl_ui_tab_bar.c
View File

@ -348,7 +348,7 @@ _layout(Evas_Object *o,
EFL_UI_TAB_BAR_DATA_GET(obj, sd); 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 _els_box_layout
(o, priv, horizontal, EINA_TRUE, efl_ui_mirrored_get(obj)); (o, priv, horizontal, EINA_TRUE, efl_ui_mirrored_get(obj));
@ -376,7 +376,7 @@ _efl_ui_tab_bar_efl_object_constructor(Eo *obj, Efl_Ui_Tab_Bar_Data *sd)
elm_widget_theme_style_get(obj)) == EFL_UI_THEME_APPLY_ERROR_GENERIC) elm_widget_theme_style_get(obj)) == EFL_UI_THEME_APPLY_ERROR_GENERIC)
CRI("Failed to set layout!"); 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)); 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_align_set(sd->bx, 0.5, 0.5);
evas_object_box_layout_set(sd->bx, _layout, obj, NULL); evas_object_box_layout_set(sd->bx, _layout, obj, NULL);

2
src/lib/elementary/efl_ui_tab_bar_private.h
View File

@ -9,7 +9,7 @@ struct _Efl_Ui_Tab_Bar_Data
Efl_Canvas_Object *bx; Efl_Canvas_Object *bx;
int cnt; int cnt;
int cur; int cur;
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
Eina_List *tab_infos; Eina_List *tab_infos;
Tab_Info *selected_tab; Tab_Info *selected_tab;

16
src/lib/elementary/efl_ui_table.c
View File

@ -90,7 +90,7 @@ _efl_ui_table_last_position_get(Eo * obj, Efl_Ui_Table_Data *pd, int *last_col,
efl_pack_table_size_get(obj, &req_cols, &req_rows); 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) EINA_INLIST_REVERSE_FOREACH(EINA_INLIST_GET(pd->items), gi)
{ {
@ -220,7 +220,7 @@ _efl_ui_table_efl_object_constructor(Eo *obj, Efl_Ui_Table_Data *pd)
efl_access_object_access_type_set(obj, EFL_ACCESS_TYPE_SKIPPED); efl_access_object_access_type_set(obj, EFL_ACCESS_TYPE_SKIPPED);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_FILLER); 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_col = -1;
pd->last_row = -1; pd->last_row = -1;
pd->req_cols = 0; pd->req_cols = 0;
@ -619,21 +619,21 @@ _efl_ui_table_efl_pack_table_table_contents_get(Eo *obj EINA_UNUSED, Efl_Ui_Tabl
} }
EOLIAN static void 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) if (pd->fill_dir == dir)
return; return;
if (dir == EFL_UI_DIR_DEFAULT) if (dir == EFL_UI_LAYOUT_ORIENTATION_DEFAULT)
dir = EFL_UI_DIR_RIGHT; dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
pd->fill_dir = dir; pd->fill_dir = dir;
efl_pack_layout_request(obj); efl_pack_layout_request(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_table_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Efl_Ui_Table_Data *pd) _efl_ui_table_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Table_Data *pd)
{ {
return pd->fill_dir; return pd->fill_dir;
} }
@ -728,7 +728,7 @@ _efl_ui_table_efl_pack_pack(Eo *obj, Efl_Ui_Table_Data *pd, Efl_Gfx_Entity *subo
_efl_ui_table_last_position_get(obj, pd, &last_col, &last_row); _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++; last_col++;
if (pd->req_cols && (last_col >= pd->req_cols)) if (pd->req_cols && (last_col >= pd->req_cols))

8
src/lib/elementary/efl_ui_table.eo
View File

@ -1,18 +1,18 @@
class @beta Efl.Ui.Table extends Efl.Ui.Widget implements Efl.Pack_Table, Efl.Pack_Layout, 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. [[Widget container that arranges its elements in a grid.
The amount of rows and columns can be controlled with @Efl.Pack_Table.table_rows 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 and @Efl.Pack_Table.table_columns, and elements can be manually positioned with
@Efl.Pack_Table.pack_table. @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 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, (horizontal or vertical) and when the amount of columns or rows has been reached,
a step is taken in the orthogonal direction. 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, In this second case there is no need to define both the amount of columns and rows,
as the table will expand as needed. 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 { methods {
@property homogeneous { @property homogeneous {
@ -37,7 +37,7 @@ class @beta Efl.Ui.Table extends Efl.Ui.Widget implements Efl.Pack_Table, Efl.Pa
Efl.Gfx.Entity.size { set; } Efl.Gfx.Entity.size { set; }
Efl.Container.content_iterate; Efl.Container.content_iterate;
Efl.Container.content_count; Efl.Container.content_count;
Efl.Ui.Direction.direction { get; set; } Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Pack.pack_clear; Efl.Pack.pack_clear;
Efl.Pack.unpack_all; Efl.Pack.unpack_all;
Efl.Pack.unpack; Efl.Pack.unpack;

2
src/lib/elementary/efl_ui_table_private.h
View File

@ -36,7 +36,7 @@ struct _Efl_Ui_Table_Data
int cols, rows; int cols, rows;
int req_cols, req_rows; // requested - 0 means infinite int req_cols, req_rows; // requested - 0 means infinite
int last_col, last_row; // only used by pack api 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 { struct {
double h, v; double h, v;
Eina_Bool scalable: 1; Eina_Bool scalable: 1;

4
src/lib/elementary/efl_ui_timepicker.c
View File

@ -125,14 +125,14 @@ _fields_init(Eo *obj)
efl_ui_range_min_max_set(efl_added, 1, 12), efl_ui_range_min_max_set(efl_added, 1, 12),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE), efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_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)); 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, pd->min = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_min_max_set(efl_added, 0, 59), efl_ui_range_min_max_set(efl_added, 0, 59),
efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE), efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_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)); efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
pd->ampm = efl_add(EFL_UI_BUTTON_CLASS, obj, pd->ampm = efl_add(EFL_UI_BUTTON_CLASS, obj,

2
src/lib/elementary/elm_colorselector.c
View File

@ -1888,7 +1888,7 @@ _palette_colors_load(Evas_Object *obj)
static inline void static inline void
_palette_box_prepare(Eo *o) _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_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
efl_gfx_entity_visible_set(o, EINA_FALSE); efl_gfx_entity_visible_set(o, EINA_FALSE);
} }

34
src/lib/elementary/elm_index.c
View File

@ -59,7 +59,7 @@ _box_custom_layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data)
ELM_INDEX_DATA_GET(data, sd); ELM_INDEX_DATA_GET(data, sd);
Eina_Bool horizontal; 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)); _els_box_layout(o, priv, horizontal, EINA_TRUE, efl_ui_mirrored_get(data));
} }
@ -242,7 +242,7 @@ _index_box_auto_fill(Evas_Object *obj,
if (sd->omit_enabled) if (sd->omit_enabled)
{ {
o = edje_object_add(evas_object_evas_get(obj)); 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 elm_widget_theme_object_set
(obj, o, "index", "item/horizontal", style); (obj, o, "index", "item/horizontal", style);
@ -333,7 +333,7 @@ _index_box_auto_fill(Evas_Object *obj,
edje_object_mirrored_set(VIEW(it), rtl); edje_object_mirrored_set(VIEW(it), rtl);
o = VIEW(it); o = VIEW(it);
if (efl_ui_dir_is_horizontal(sd->dir, EINA_FALSE)) if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_FALSE))
{ {
if (i & 0x1) if (i & 0x1)
elm_widget_theme_object_set elm_widget_theme_object_set
@ -445,7 +445,7 @@ _elm_index_efl_ui_widget_theme_apply(Eo *obj, Elm_Index_Data *sd)
_index_box_clear(obj, 0); _index_box_clear(obj, 0);
_index_box_clear(obj, 1); _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"); elm_widget_theme_element_set(obj, "base/horizontal");
else else
elm_widget_theme_element_set(obj, "base/vertical"); elm_widget_theme_element_set(obj, "base/vertical");
@ -662,7 +662,7 @@ _sel_eval(Evas_Object *obj,
x = (x * x) + (y * y); x = (x * x) + (y * y);
if ((x < dist) || (!it_closest)) 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; cdv = (double)(xx - bx) / (double)bw;
else else
cdv = (double)(yy - by) / (double)bh; cdv = (double)(yy - by) / (double)bh;
@ -902,7 +902,7 @@ _on_mouse_move(void *data,
(wd->resize_obj, "elm.dragable.pointer", (wd->resize_obj, "elm.dragable.pointer",
(!edje_object_mirrored_get(wd->resize_obj)) ? (!edje_object_mirrored_get(wd->resize_obj)) ?
x : (x - w), y); 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) if (adx > minw)
{ {
@ -1093,7 +1093,7 @@ _elm_index_efl_canvas_group_group_add(Eo *obj, Elm_Index_Data *priv)
evas_object_show(priv->bx[0]); evas_object_show(priv->bx[0]);
priv->delay_change_time = INDEX_DELAY_CHANGE_TIME; priv->delay_change_time = INDEX_DELAY_CHANGE_TIME;
priv->dir = EFL_UI_DIR_VERTICAL; priv->dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
if (edje_object_part_exists if (edje_object_part_exists
(wd->resize_obj, "elm.swallow.index.1")) (wd->resize_obj, "elm.swallow.index.1"))
@ -1191,16 +1191,16 @@ elm_index_add(Evas_Object *parent)
EAPI void elm_index_horizontal_set(Evas_Object *obj, Eina_Bool horizontal) 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) 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 Eo *
@ -1571,21 +1571,21 @@ _elm_index_item_letter_get(const Eo *item EINA_UNUSED, Elm_Index_Item_Data *it)
} }
EOLIAN static void 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. // Adjust direction to be either horizontal or vertical.
if (efl_ui_dir_is_horizontal(dir, EINA_FALSE)) if (efl_ui_layout_orientation_is_horizontal(dir, EINA_FALSE))
dir = EFL_UI_DIR_HORIZONTAL; dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else else
dir = EFL_UI_DIR_VERTICAL; dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
sd->dir = dir; sd->dir = dir;
efl_ui_widget_theme_apply(obj); efl_ui_widget_theme_apply(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_elm_index_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Elm_Index_Data *sd) _elm_index_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Elm_Index_Data *sd)
{ {
return sd->dir; return sd->dir;
} }

10
src/lib/elementary/elm_index_eo.c
View File

@ -244,10 +244,10 @@ Eina_Error _elm_index_efl_ui_widget_theme_apply(Eo *obj, Elm_Index_Data *pd);
void _elm_index_efl_ui_widget_on_access_update(Eo *obj, Elm_Index_Data *pd, Eina_Bool enable); 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); Eina_List *_elm_index_efl_access_object_access_children_get(const Eo *obj, Elm_Index_Data *pd);
@ -289,8 +289,8 @@ _elm_index_class_initializer(Efl_Class *klass)
EFL_OBJECT_OP_FUNC(efl_constructor, _elm_index_efl_object_constructor), 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_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_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_layout_orientation_set, _elm_index_efl_ui_layout_orientable_orientation_set),
EFL_OBJECT_OP_FUNC(efl_ui_direction_get, _elm_index_efl_ui_direction_direction_get), 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_access_object_access_children_get, _elm_index_efl_access_object_access_children_get),
ELM_INDEX_EXTRA_OPS ELM_INDEX_EXTRA_OPS
); );
@ -322,6 +322,6 @@ static const Efl_Class_Description _elm_index_class_desc = {
NULL 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" #include "elm_index_eo.legacy.c"

28
src/lib/elementary/elm_priv.h
View File

@ -986,18 +986,26 @@ _##_pfx##_efl_ui_widget_widget_input_event_handler(Eo *obj, _typ *_pd EINA_UNUSE
return EINA_TRUE; \ return EINA_TRUE; \
} }
static inline Eina_Bool static inline Efl_Ui_Layout_Orientation
efl_ui_dir_is_horizontal(Efl_Ui_Dir dir, Eina_Bool def_val) efl_ui_layout_orientation_axis_get(Efl_Ui_Layout_Orientation orient)
{ {
switch (dir) 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_layout_orientation_is_horizontal(Efl_Ui_Layout_Orientation orient, Eina_Bool def_val)
{
switch (orient & EFL_UI_LAYOUT_ORIENTATION_AXIS_BITMASK)
{ {
case EFL_UI_DIR_DEFAULT: return !!def_val; case EFL_UI_LAYOUT_ORIENTATION_DEFAULT: return !!def_val;
case EFL_UI_DIR_HORIZONTAL: return EINA_TRUE; case EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL: return EINA_TRUE;
case EFL_UI_DIR_VERTICAL: return EINA_FALSE; case EFL_UI_LAYOUT_ORIENTATION_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;
default: return !!def_val; default: return !!def_val;
} }
} }

90
src/lib/elementary/elm_slider.c
View File

@ -71,37 +71,9 @@ _delay_change(void *data)
} }
static inline Eina_Bool 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); return efl_ui_layout_orientation_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;
}
} }
static void static void
@ -330,7 +302,7 @@ _drag_up(void *data,
EFL_UI_SLIDER_DATA_GET(data, sd); EFL_UI_SLIDER_DATA_GET(data, sd);
step = sd->step; 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); ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
efl_ui_drag_step_move(efl_part(wd->resize_obj, "elm.dragable.slider"), efl_ui_drag_step_move(efl_part(wd->resize_obj, "elm.dragable.slider"),
@ -348,7 +320,7 @@ _drag_down(void *data,
EFL_UI_SLIDER_DATA_GET(data, sd); EFL_UI_SLIDER_DATA_GET(data, sd);
step = -sd->step; 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); ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
efl_ui_drag_step_move(efl_part(wd->resize_obj, "elm.dragable.slider"), efl_ui_drag_step_move(efl_part(wd->resize_obj, "elm.dragable.slider"),
@ -365,7 +337,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (!_is_horizontal(sd->dir)) if (!_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (!_is_inverted(sd->dir)) if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL); _drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL); else _drag_up(obj, NULL, NULL, NULL);
} }
@ -373,7 +345,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (!_is_horizontal(sd->dir)) if (!_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (!_is_inverted(sd->dir)) if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL); _drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL); else _drag_down(obj, NULL, NULL, NULL);
} }
@ -381,7 +353,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (_is_horizontal(sd->dir)) if (_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (_is_inverted(sd->dir)) if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj, NULL, NULL, NULL); _drag_up(obj, NULL, NULL, NULL);
else _drag_down(obj, NULL, NULL, NULL); else _drag_down(obj, NULL, NULL, NULL);
} }
@ -389,7 +361,7 @@ _key_action_drag(Evas_Object *obj, const char *params)
{ {
if (_is_horizontal(sd->dir)) if (_is_horizontal(sd->dir))
return EINA_FALSE; return EINA_FALSE;
if (_is_inverted(sd->dir)) if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj, NULL, NULL, NULL); _drag_down(obj, NULL, NULL, NULL);
else _drag_up(obj, NULL, NULL, NULL); else _drag_up(obj, NULL, NULL, NULL);
} }
@ -505,7 +477,7 @@ _popup_update(Evas_Object *obj, Elm_Slider_Data *sd, Evas_Object *popup)
edje_object_scale_set(popup, efl_gfx_entity_scale_get(obj) * edje_object_scale_set(popup, efl_gfx_entity_scale_get(obj) *
elm_config_scale_get()); 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"); edje_object_signal_emit(popup, "elm,state,inverted,off", "elm");
else else
edje_object_signal_emit(popup, "elm,state,inverted,on", "elm"); edje_object_signal_emit(popup, "elm,state,inverted,on", "elm");
@ -563,7 +535,6 @@ _popup_add(Elm_Slider_Data *sd, Eo *obj, Evas_Object **popup,
void void
_elm_slider_val_fetch(Evas_Object *obj, Elm_Slider_Data *pd, Eina_Bool user_event) _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 posx = 0.0, posy = 0.0, pos = 0.0, val;
double posx2 = 0.0, posy2 = 0.0, pos2 = 0.0, val2; double posx2 = 0.0, posy2 = 0.0, pos2 = 0.0, val2;
Eina_Bool inverted = EINA_FALSE; Eina_Bool inverted = EINA_FALSE;
@ -574,18 +545,15 @@ _elm_slider_val_fetch(Evas_Object *obj, Elm_Slider_Data *pd, Eina_Bool user_even
efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable.slider"), efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable.slider"),
&posx, &posy); &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; else pos = posy;
efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable2.slider"), efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable2.slider"),
&posx2, &posy2); &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; else pos2 = posy2;
rtl = efl_ui_mirrored_get(obj); if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
if ((!rtl && _is_inverted(sd->dir)) ||
(rtl && ((sd->dir == EFL_UI_DIR_UP) ||
(sd->dir == EFL_UI_DIR_RIGHT))))
{ {
pos = 1.0 - pos; pos = 1.0 - pos;
pos2 = 1.0 - pos2; pos2 = 1.0 - pos2;
@ -651,7 +619,6 @@ _elm_slider_val_fetch(Evas_Object *obj, Elm_Slider_Data *pd, Eina_Bool user_even
void void
_elm_slider_val_set(Evas_Object *obj, Elm_Slider_Data *pd EINA_UNUSED) _elm_slider_val_set(Evas_Object *obj, Elm_Slider_Data *pd EINA_UNUSED)
{ {
Eina_Bool rtl;
double pos, pos2; double pos, pos2;
EFL_UI_SLIDER_DATA_GET(obj, sd); EFL_UI_SLIDER_DATA_GET(obj, sd);
@ -677,10 +644,7 @@ _elm_slider_val_set(Evas_Object *obj, Elm_Slider_Data *pd EINA_UNUSED)
else if (pos2 > 1.0) else if (pos2 > 1.0)
pos2 = 1.0; pos2 = 1.0;
rtl = efl_ui_mirrored_get(obj); if (efl_ui_mirrored_get(obj) ^ efl_ui_layout_orientation_is_inverted(sd->dir))
if ((!rtl && _is_inverted(sd->dir)) ||
(rtl && ((sd->dir == EFL_UI_DIR_UP) ||
(sd->dir == EFL_UI_DIR_RIGHT))))
{ {
pos = 1.0 - pos; pos = 1.0 - pos;
pos2 = 1.0 - pos2; pos2 = 1.0 - pos2;
@ -718,7 +682,7 @@ _elm_slider_down_knob(Evas_Object *obj, Elm_Slider_Data *pd, double button_x, do
efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable2.slider"), efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable2.slider"),
&posx2, &posy2); &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); diff1 = fabs(button_x - posx);
diff2 = fabs(button_x - posx2); diff2 = fabs(button_x - posx2);
@ -836,7 +800,7 @@ _elm_slider_efl_ui_widget_theme_apply(Eo *obj, Elm_Slider_Data *sd)
else else
elm_layout_signal_emit(obj, "elm,slider,range,disable", "elm"); 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"); elm_layout_signal_emit(obj, "elm,state,inverted,on", "elm");
else else
elm_layout_signal_emit(obj, "elm,state,inverted,off", "elm"); elm_layout_signal_emit(obj, "elm,state,inverted,off", "elm");
@ -1235,12 +1199,13 @@ elm_slider_unit_format_get(const Evas_Object *obj)
EAPI void EAPI void
elm_slider_horizontal_set(Evas_Object *obj, Eina_Bool horizontal) 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); 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 EAPI Eina_Bool
@ -1248,8 +1213,8 @@ elm_slider_horizontal_get(const Evas_Object *obj)
{ {
EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE);
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
dir = efl_ui_direction_get(obj); dir = efl_ui_layout_orientation_get(obj);
return _is_horizontal(dir); return _is_horizontal(dir);
} }
@ -1281,21 +1246,22 @@ elm_slider_value_get(const Evas_Object *obj)
EAPI void EAPI void
elm_slider_inverted_set(Evas_Object *obj, Eina_Bool inverted) 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); 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 EAPI Eina_Bool
elm_slider_inverted_get(const Evas_Object *obj) elm_slider_inverted_get(const Evas_Object *obj)
{ {
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
dir = efl_ui_direction_get(obj); dir = efl_ui_layout_orientation_get(obj);
return _is_inverted(dir); return efl_ui_layout_orientation_is_inverted(dir);
} }
typedef struct typedef struct

84
src/lib/elementary/elm_toolbar.c
View File

@ -116,7 +116,7 @@ _items_visibility_fix(Elm_Toolbar *obj,
if (sd->more_item) if (sd->more_item)
{ {
evas_object_geometry_get(sd->VIEW(more_item), NULL, NULL, &ciw, &cih); 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; else *iw += ciw;
} }
@ -125,7 +125,7 @@ _items_visibility_fix(Elm_Toolbar *obj,
if (it->prio.priority > sd->standard_priority) if (it->prio.priority > sd->standard_priority)
{ {
evas_object_geometry_get(VIEW(it), NULL, NULL, &ciw, &cih); 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; else *iw += ciw;
//expand is the case where the bx_more stuff is used and the prio.visible is completly ignored. //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 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)
@ -298,7 +298,7 @@ _items_size_fit(Evas_Object *obj, Evas_Coord *bl, Evas_Coord view)
if (mw != -1 || mh != -1) 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; else min = mw;
if ((!full) && ((sumf + min) > view)) if ((!full) && ((sumf + min) > view))
@ -396,7 +396,7 @@ _resize_job(void *data)
{ {
Evas_Coord iw = 0, ih = 0, more_w = 0, more_h = 0; 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; h = vh;
_items_visibility_fix(obj, sd, &ih, vh, EINA_FALSE, &more); _items_visibility_fix(obj, sd, &ih, vh, EINA_FALSE, &more);
@ -409,7 +409,7 @@ _resize_job(void *data)
evas_object_geometry_get evas_object_geometry_get
(sd->VIEW(more_item), NULL, NULL, &more_w, &more_h); (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; if ((ih - more_h) <= vh) ih -= more_h;
} }
@ -422,8 +422,8 @@ _resize_job(void *data)
* individual items won't trigger a resize. Items are be * individual items won't trigger a resize. Items are be
* readded below. */ * readded below. */
evas_object_box_remove_all(sd->bx, EINA_FALSE); evas_object_box_remove_all(sd->bx, EINA_FALSE);
if ((!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) || if ((!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) ||
( efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) || ( efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) ||
more) more)
{ {
Evas_Object *menu; Evas_Object *menu;
@ -477,7 +477,7 @@ _resize_job(void *data)
{ {
Evas_Coord iw = 0, ih = 0; 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; h = vh;
_items_visibility_fix(obj, sd, &ih, vh, EINA_FALSE, &more); _items_visibility_fix(obj, sd, &ih, vh, EINA_FALSE, &more);
@ -488,8 +488,8 @@ _resize_job(void *data)
_items_visibility_fix(obj, sd, &iw, vw, EINA_FALSE, &more); _items_visibility_fix(obj, sd, &iw, vw, EINA_FALSE, &more);
} }
evas_object_box_remove_all(sd->bx, EINA_FALSE); evas_object_box_remove_all(sd->bx, EINA_FALSE);
if ((!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) || if ((!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (ih > vh)) ||
( efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) || ( efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iw > vw)) ||
more) more)
{ {
EINA_INLIST_FOREACH(sd->items, it) EINA_INLIST_FOREACH(sd->items, it)
@ -517,12 +517,12 @@ _resize_job(void *data)
{ {
Evas_Coord iw = 0, ih = 0; 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; h = (vh >= mh) ? vh : mh;
else else
w = (vw >= mw) ? vw : mw; 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); _items_visibility_fix(obj, sd, &ih, vh, EINA_TRUE, &more);
else else
_items_visibility_fix(obj, sd, &iw, vw, EINA_TRUE, &more); _items_visibility_fix(obj, sd, &iw, vw, EINA_TRUE, &more);
@ -547,7 +547,7 @@ _resize_job(void *data)
else else
evas_object_hide(sd->VIEW(more_item)); 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 (h > vh) _items_size_fit(obj, &h, vh);
if (sd->item_count - sd->separator_count > 0) if (sd->item_count - sd->separator_count > 0)
@ -564,7 +564,7 @@ _resize_job(void *data)
} }
else 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; h = (vh >= mh) ? vh : mh;
else else
w = (vw >= mw) ? vw : mw; w = (vw >= mw) ? vw : mw;
@ -578,7 +578,7 @@ _resize_job(void *data)
if (sd->transverse_expanded) 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; w = vw;
else else
h = vh; h = vh;
@ -723,8 +723,8 @@ _elm_toolbar_nearest_visible_item_get(Evas_Object *obj, Elm_Object_Item *eo_it)
item_list = evas_object_box_children_get(sd->bx); item_list = evas_object_box_children_get(sd->bx);
if ((!efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iy < vy)) || if ((!efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iy < vy)) ||
( efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE) && (iw < vw)) || ( efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE) && (iw < vw)) ||
search_next) search_next)
{ {
while ((item_list = eina_list_next(item_list))) while ((item_list = eina_list_next(item_list)))
@ -1319,7 +1319,7 @@ _item_theme_hook(Evas_Object *obj,
_item_shrink_signal_emit(view, sd->shrink_mode); _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"); elm_layout_signal_emit(view, "elm,orient,vertical", "elm");
else else
elm_layout_signal_emit(view, "elm,orient,horizontal", "elm"); elm_layout_signal_emit(view, "elm,orient,horizontal", "elm");
@ -1329,7 +1329,7 @@ _item_theme_hook(Evas_Object *obj,
elm_coords_finger_size_adjust(1, &mw, 1, &mh); elm_coords_finger_size_adjust(1, &mw, 1, &mh);
if (sd->shrink_mode != ELM_TOOLBAR_SHRINK_EXPAND) 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_weight_set(view, EVAS_HINT_EXPAND, -1.0);
evas_object_size_hint_align_set evas_object_size_hint_align_set
@ -1421,7 +1421,7 @@ _sizing_eval(Evas_Object *obj)
} }
else if (sd->shrink_mode == ELM_TOOLBAR_SHRINK_EXPAND) 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); minw = minw_bx + (w - vw);
if (minh_bx <= vh) minh_bx = vh; if (minh_bx <= vh) minh_bx = vh;
@ -1436,7 +1436,7 @@ _sizing_eval(Evas_Object *obj)
} }
else 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); minw = minw_bx + (w - vw);
minh = h - vh; minh = h - vh;
@ -1450,7 +1450,7 @@ _sizing_eval(Evas_Object *obj)
if (sd->transverse_expanded) 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; minw_bx = vw;
else else
minh_bx = vh; minh_bx = vh;
@ -1497,7 +1497,7 @@ _elm_toolbar_efl_ui_widget_theme_apply(Eo *obj, Elm_Toolbar_Data *sd)
elm_widget_theme_object_set elm_widget_theme_object_set
(obj, wd->resize_obj, "toolbar", "base", (obj, wd->resize_obj, "toolbar", "base",
elm_widget_style_get(obj)); 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"); edje_object_signal_emit(wd->resize_obj, "elm,orient,vertical", "elm");
else else
edje_object_signal_emit(wd->resize_obj, "elm,orient,horizontal", "elm"); edje_object_signal_emit(wd->resize_obj, "elm,orient,horizontal", "elm");
@ -1505,7 +1505,7 @@ _elm_toolbar_efl_ui_widget_theme_apply(Eo *obj, Elm_Toolbar_Data *sd)
if (!elm_layout_theme_set if (!elm_layout_theme_set
(sd->more, "toolbar", "more", elm_widget_style_get(obj))) (sd->more, "toolbar", "more", elm_widget_style_get(obj)))
CRI("Failed to set layout!"); 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"); elm_object_signal_emit(sd->more, "elm,orient,vertical", "elm");
else else
elm_object_signal_emit(sd->more, "elm,orient,horizontal", "elm"); elm_object_signal_emit(sd->more, "elm,orient,horizontal", "elm");
@ -1987,7 +1987,7 @@ _mouse_move_reorder(Elm_Toolbar_Item_Data *item,
ELM_TOOLBAR_DATA_GET(WIDGET(item), sd); ELM_TOOLBAR_DATA_GET(WIDGET(item), sd);
evas_object_geometry_get(VIEW(item), &x, &y, &w, &h); 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)); evas_object_move(item->proxy, x, ev->cur.canvas.y - (h / 2));
else else
evas_object_move(item->proxy, ev->cur.canvas.x - (w / 2), y); evas_object_move(item->proxy, ev->cur.canvas.x - (w / 2), y);
@ -2265,7 +2265,7 @@ _layout(Evas_Object *o,
ELM_TOOLBAR_DATA_GET(obj, sd); 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 _els_box_layout
(o, priv, horizontal, sd->homogeneous, efl_ui_mirrored_get(obj)); (o, priv, horizontal, sd->homogeneous, efl_ui_mirrored_get(obj));
@ -2762,7 +2762,7 @@ _elm_toolbar_efl_canvas_group_group_add(Eo *obj, Elm_Toolbar_Data *priv)
elm_interface_scrollable_objects_set(obj, edje, priv->hit_rect); elm_interface_scrollable_objects_set(obj, edje, priv->hit_rect);
priv->standard_priority = -99999; priv->standard_priority = -99999;
priv->dir = EFL_UI_DIR_HORIZONTAL; priv->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
elm_interface_scrollable_bounce_allow_set elm_interface_scrollable_bounce_allow_set
(obj, _elm_config->thumbscroll_bounce_enable, EINA_FALSE); (obj, _elm_config->thumbscroll_bounce_enable, EINA_FALSE);
@ -2800,7 +2800,7 @@ _elm_toolbar_efl_canvas_group_group_add(Eo *obj, Elm_Toolbar_Data *priv)
priv->more = elm_layout_add(obj); priv->more = elm_layout_add(obj);
if (!elm_layout_theme_set(priv->more, "toolbar", "more", "default")) if (!elm_layout_theme_set(priv->more, "toolbar", "more", "default"))
CRI("Failed to set layout!"); 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"); elm_object_signal_emit(priv->more, "elm,orient,vertical", "elm");
else else
elm_object_signal_emit(priv->more, "elm,orient,horizontal", "elm"); elm_object_signal_emit(priv->more, "elm,orient,horizontal", "elm");
@ -2920,7 +2920,7 @@ _elm_toolbar_coordinates_adjust(Elm_Toolbar_Item_Data *it)
evas_object_geometry_get(VIEW(it), &ix, &iy, &iw, &ih); evas_object_geometry_get(VIEW(it), &ix, &iy, &iw, &ih);
r = EINA_RECT(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. //TODO: Enhance it later.
if ((ix < vx) || (ix + iw) > (vx + vw) || (iy + ih) > (vy + vh)) if ((ix < vx) || (ix + iw) > (vx + vw) || (iy + ih) > (vy + vh))
@ -3483,7 +3483,7 @@ _elm_toolbar_menu_parent_get(const Eo *obj EINA_UNUSED, Elm_Toolbar_Data *sd)
EOLIAN static void EOLIAN static void
_elm_toolbar_align_set(Eo *obj EINA_UNUSED, Elm_Toolbar_Data *sd, double align) _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) if (sd->align != align)
evas_object_box_align_set(sd->bx, 0.5, align); evas_object_box_align_set(sd->bx, 0.5, align);
@ -3712,17 +3712,17 @@ _elm_toolbar_item_state_prev(Eo *eo_item EINA_UNUSED, Elm_Toolbar_Item_Data *ite
} }
EOLIAN static void 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. // Adjust direction to be either horizontal or vertical.
if (efl_ui_dir_is_horizontal(dir, EINA_TRUE)) if (efl_ui_layout_orientation_is_horizontal(dir, EINA_TRUE))
dir = EFL_UI_DIR_HORIZONTAL; dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else else
dir = EFL_UI_DIR_VERTICAL; dir = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
sd->dir = dir; 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); evas_object_box_align_set(sd->bx, 0.5, sd->align);
else else
evas_object_box_align_set(sd->bx, sd->align, 0.5); evas_object_box_align_set(sd->bx, sd->align, 0.5);
@ -3730,8 +3730,8 @@ _elm_toolbar_efl_ui_direction_direction_set(Eo *obj, Elm_Toolbar_Data *sd, Efl_U
_sizing_eval(obj); _sizing_eval(obj);
} }
EOLIAN static Efl_Ui_Dir EOLIAN static Efl_Ui_Layout_Orientation
_elm_toolbar_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Elm_Toolbar_Data *sd) _elm_toolbar_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Elm_Toolbar_Data *sd)
{ {
return sd->dir; return sd->dir;
} }
@ -3739,14 +3739,14 @@ _elm_toolbar_efl_ui_direction_direction_get(const Eo *obj EINA_UNUSED, Elm_Toolb
EAPI void EAPI void
elm_toolbar_horizontal_set(Evas_Object *obj, Eina_Bool horizontal) elm_toolbar_horizontal_set(Evas_Object *obj, Eina_Bool horizontal)
{ {
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
if (horizontal) if (horizontal)
dir = EFL_UI_DIR_HORIZONTAL; dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
else 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 EAPI Eina_Bool
@ -3754,7 +3754,7 @@ elm_toolbar_horizontal_get(const Evas_Object *obj)
{ {
ELM_TOOLBAR_DATA_GET_OR_RETURN_VAL(obj, sd, EINA_FALSE); 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 EOLIAN static unsigned int

10
src/lib/elementary/elm_toolbar_eo.c
View File

@ -235,10 +235,10 @@ Eina_Rect _elm_toolbar_efl_ui_widget_focus_highlight_geometry_get(const Eo *obj,
Elm_Widget_Item *_elm_toolbar_elm_widget_item_container_focused_item_get(const Eo *obj, Elm_Toolbar_Data *pd); Elm_Widget_Item *_elm_toolbar_elm_widget_item_container_focused_item_get(const Eo *obj, Elm_Toolbar_Data *pd);
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); 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);
@ -329,8 +329,8 @@ _elm_toolbar_class_initializer(Efl_Class *klass)
EFL_OBJECT_OP_FUNC(efl_ui_widget_input_event_handler, _elm_toolbar_efl_ui_widget_widget_input_event_handler), EFL_OBJECT_OP_FUNC(efl_ui_widget_input_event_handler, _elm_toolbar_efl_ui_widget_widget_input_event_handler),
EFL_OBJECT_OP_FUNC(efl_ui_widget_focus_highlight_geometry_get, _elm_toolbar_efl_ui_widget_focus_highlight_geometry_get), 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(elm_widget_item_container_focused_item_get, _elm_toolbar_elm_widget_item_container_focused_item_get),
EFL_OBJECT_OP_FUNC(efl_ui_direction_set, _elm_toolbar_efl_ui_direction_direction_set), EFL_OBJECT_OP_FUNC(efl_ui_layout_orientation_set, _elm_toolbar_efl_ui_layout_orientable_orientation_set),
EFL_OBJECT_OP_FUNC(efl_ui_direction_get, _elm_toolbar_efl_ui_direction_direction_get), 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_focus_state_apply, _elm_toolbar_efl_ui_widget_focus_state_apply),
EFL_OBJECT_OP_FUNC(efl_access_widget_action_elm_actions_get, _elm_toolbar_efl_access_widget_action_elm_actions_get), EFL_OBJECT_OP_FUNC(efl_access_widget_action_elm_actions_get, _elm_toolbar_efl_access_widget_action_elm_actions_get),
EFL_OBJECT_OP_FUNC(efl_access_object_access_children_get, _elm_toolbar_efl_access_object_access_children_get), EFL_OBJECT_OP_FUNC(efl_access_object_access_children_get, _elm_toolbar_efl_access_object_access_children_get),
@ -372,6 +372,6 @@ static const Efl_Class_Description _elm_toolbar_class_desc = {
NULL 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" #include "elm_toolbar_eo.legacy.c"

2
src/lib/elementary/elm_widget_index.h
View File

@ -36,7 +36,7 @@ struct _Elm_Index_Data
* small */ * small */
Eina_List *omit; Eina_List *omit;
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
int level; int level;
Evas_Coord dx, dy; Evas_Coord dx, dy;
Ecore_Timer *delay; Ecore_Timer *delay;

2
src/lib/elementary/elm_widget_toolbar.h
View File

@ -49,7 +49,7 @@ struct _Elm_Toolbar_Data
Elm_Object_Select_Mode select_mode; Elm_Object_Select_Mode select_mode;
Ecore_Timer *long_timer; Ecore_Timer *long_timer;
Ecore_Job *resize_job; Ecore_Job *resize_job;
Efl_Ui_Dir dir; Efl_Ui_Layout_Orientation dir;
Eina_Bool long_press : 1; Eina_Bool long_press : 1;
Eina_Bool homogeneous : 1; Eina_Bool homogeneous : 1;

18
src/tests/elementary/efl_ui_test_box.c
View File

@ -254,7 +254,7 @@ EFL_START_TEST (efl_ui_box_layout_update)
int i, max_index = (sizeof(hints) / sizeof(Hint)); int i, max_index = (sizeof(hints) / sizeof(Hint));
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2); 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, Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
efl_pack_end(layout, efl_added)); efl_pack_end(layout, efl_added));
@ -273,7 +273,7 @@ EFL_START_TEST (efl_ui_box_layout_update_pack)
Eo *btn, *btn2, *btn3; Eo *btn, *btn2, *btn3;
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2); 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_index2 = ((sizeof(hints2) / sizeof(Hint)) / 2);
max_index3 = ((sizeof(hints3) / sizeof(Hint)) / 3); max_index3 = ((sizeof(hints3) / sizeof(Hint)) / 3);
@ -319,7 +319,7 @@ EFL_START_TEST (efl_ui_box_layout_update_pack)
btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2)); btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2));
btn_geom_assert(&hints3[3][2], efl_gfx_entity_geometry_get(btn3)); 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][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][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); hints3[3][2].layout_expected = hints3[3][2].layout_size = EINA_SIZE2D(300, 900);
@ -369,7 +369,7 @@ EFL_START_TEST (efl_ui_box_size)
Eo *btn, *btn2, *btn3; Eo *btn, *btn2, *btn3;
Eina_Size2D min, user_min; 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, btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 100)), efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 100)),
@ -536,13 +536,13 @@ EFL_START_TEST (efl_ui_box_properties)
ck_assert_int_eq(b, 1); ck_assert_int_eq(b, 1);
//direction test //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); efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_DEFAULT);
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_HORIZONTAL); efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_HORIZONTAL); ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
//homogeneous test //homogeneous test
ck_assert_int_eq(efl_ui_box_homogeneous_get(layout), 0); ck_assert_int_eq(efl_ui_box_homogeneous_get(layout), 0);

4
src/tests/elementary/efl_ui_test_box_flow.c
View File

@ -225,7 +225,7 @@ layout_setup()
layout = efl_add(EFL_UI_BOX_FLOW_CLASS, win, layout = efl_add(EFL_UI_BOX_FLOW_CLASS, win,
efl_gfx_arrangement_content_align_set(efl_added, 0.8, 0.2), 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 static void
@ -313,7 +313,7 @@ EFL_START_TEST (efl_ui_box_flow_layout_update_pack)
btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2)); btn_geom_assert(&hints3[3][1], efl_gfx_entity_geometry_get(btn2));
btn_geom_assert(&hints3[3][2], efl_gfx_entity_geometry_get(btn3)); 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][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][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); hints3[3][2].layout_expected = hints3[3][2].layout_size = EINA_SIZE2D(300, 900);

2
src/tests/elementary/efl_ui_test_box_stack.c
View File

@ -134,7 +134,7 @@ layout_setup()
layout = efl_add(EFL_UI_BOX_STACK_CLASS, win, layout = efl_add(EFL_UI_BOX_STACK_CLASS, win,
efl_gfx_arrangement_content_align_set(efl_added, 0.8, 0.2), 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 static void

24
src/tests/elementary/efl_ui_test_table.c
View File

@ -280,7 +280,7 @@ EFL_START_TEST (efl_ui_table_layout_update)
int i, max_index = (sizeof(hints) / sizeof(Hint)); int i, max_index = (sizeof(hints) / sizeof(Hint));
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2); 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, Eo *btn = efl_add(EFL_UI_BUTTON_CLASS, layout,
efl_pack_table(layout, efl_added, 0, 0, 1, 1)); efl_pack_table(layout, efl_added, 0, 0, 1, 1));
@ -299,7 +299,7 @@ EFL_START_TEST (efl_ui_table_layout_update_pack)
Eo *btn, *btn2, *btn3; Eo *btn, *btn2, *btn3;
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2); 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_index2 = ((sizeof(hints2) / sizeof(Hint)) / 2);
max_index3 = ((sizeof(hints3) / sizeof(Hint)) / 3); max_index3 = ((sizeof(hints3) / sizeof(Hint)) / 3);
@ -338,7 +338,7 @@ EFL_START_TEST (efl_ui_table_layout_update_matrix)
Eo *btn[9]; Eo *btn[9];
efl_gfx_arrangement_content_align_set(layout, 0.8, 0.2); 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_gfx_hint_margin_set(layout, 10, 10, 20, 20);
efl_ui_table_homogeneous_set(layout, 0, 1); efl_ui_table_homogeneous_set(layout, 0, 1);
@ -523,19 +523,19 @@ EFL_START_TEST (efl_ui_table_properties)
ck_assert_int_eq(b, 1); ck_assert_int_eq(b, 1);
//direction test //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); efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_VERTICAL);
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_RIGHT); efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
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_DEFAULT); efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_DEFAULT);
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_HORIZONTAL); efl_ui_layout_orientation_set(layout, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
ck_assert_int_eq(efl_ui_direction_get(layout), EFL_UI_DIR_HORIZONTAL); ck_assert_int_eq(efl_ui_layout_orientation_get(layout), EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
//homogeneous test //homogeneous test
efl_ui_table_homogeneous_get(layout, &homogeneoush, &homogeneousv); efl_ui_table_homogeneous_get(layout, &homogeneoush, &homogeneousv);