Summary: since to control the rotation of application windows by WM, already added related feature in Ecore_Evas. Added related API for it.
Reviewers: raster, seoz
CC: gwanglim
Differential Revision: https://phab.enlightenment.org/D542
test_win_socket.c \
test_win_plug.c \
test_win_state.c \
+test_win_wm_rotation.c \
test.h
elementary_test_LDADD = $(top_builddir)/src/lib/libelementary.la \
void test_win_inline(void *data, Evas_Object *obj, void *event_info);
void test_win_socket(void *data, Evas_Object *obj, void *event_info);
void test_win_plug(void *data, Evas_Object *obj, void *event_info);
+void test_win_wm_rotation(void *data, Evas_Object *obj, void *event_info);
void test_grid(void *data, Evas_Object *obj, void *event_info);
void test_glview_simple(void *data, Evas_Object *obj, void *event_info);
void test_glview(void *data, Evas_Object *obj, void *event_info);
ADD_TEST(NULL, "Window / Background", "Window Inline", test_win_inline);
ADD_TEST(NULL, "Window / Background", "Window Socket", test_win_socket);
ADD_TEST(NULL, "Window / Background", "Window Plug", test_win_plug);
+ ADD_TEST(NULL, "Window / Background", "Window WM Rotation", test_win_wm_rotation);
//------------------------------//
ADD_TEST(NULL, "Images", "Icon", test_icon);
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+#include <Elementary.h>
+
+typedef struct _App_Data App_Data;
+
+struct _App_Data
+{
+ Eina_Bool wm_rot_supported;
+ Eina_List *chs;
+ int available_rots[4];
+ Evas_Object *lb;
+ Evas_Object *rdg;
+};
+
+static void
+_bt_available_rots_set(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+ Evas_Object *win = data;
+ App_Data *ad = evas_object_data_get(win, "ad");
+ Evas_Object *o;
+ Eina_List *l;
+ const char *str;
+ unsigned int i = 0;
+
+ if (!ad->wm_rot_supported) return;
+
+ EINA_LIST_FOREACH(ad->chs, l, o)
+ {
+ if (!elm_check_state_get(o)) continue;
+ str = elm_object_text_get(o);
+ if (!str) continue;
+ ad->available_rots[i] = atoi(str);
+ i++;
+ }
+
+ elm_win_wm_rotation_available_rotations_set
+ (win, ad->available_rots, i);
+}
+
+static void
+_bt_preferred_rot_set(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+ Evas_Object *win = (Evas_Object *)(data);
+ App_Data *ad = evas_object_data_get(win, "ad");
+
+ if (!ad->wm_rot_supported) return;
+
+ Evas_Object *rd = elm_radio_selected_object_get(ad->rdg);
+ if (rd)
+ {
+ const char *str = elm_object_text_get(rd);
+ int rot = 0;
+
+ if (!strcmp(str, "Unset"))
+ rot = -1;
+ else
+ rot = atoi(str);
+
+ elm_win_wm_rotation_preferred_rotation_set(win, rot);
+ }
+}
+
+static void
+_win_wm_rotation_changed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
+{
+ Evas_Object *win = data;
+ App_Data *ad = evas_object_data_get(win, "ad");
+ int rot = elm_win_rotation_get(win);
+ char buf[32];
+
+ if (!ad->wm_rot_supported) return;
+
+ eina_convert_itoa(rot, buf);
+ elm_object_text_set(ad->lb, eina_stringshare_add(buf));
+}
+
+static void
+_win_del_cb(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
+{
+ App_Data *ad = evas_object_data_get(obj, "ad");
+ Evas_Object *o;
+
+ if (ad->wm_rot_supported)
+ {
+ EINA_LIST_FREE(ad->chs, o)
+ evas_object_data_del(o, "rotation");
+ }
+
+ free(ad);
+}
+
+void
+test_win_wm_rotation(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+ App_Data *ad;
+ Evas_Object *win, *bx, *bx2, *lb, *ch, *bt, *en, *rd, *rdg = NULL;
+ int i;
+ char buf[32];
+
+ if (!(ad = calloc(1, sizeof(App_Data)))) return;
+
+ win = elm_win_util_standard_add("wmrotation", "WMRotation");
+ elm_win_autodel_set(win, EINA_TRUE);
+ evas_object_data_set(win, "ad", ad);
+
+ bx = elm_box_add(win);
+ evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_win_resize_object_add(win, bx);
+
+ lb = elm_label_add(win);
+ elm_object_text_set(lb, "<b>Window manager rotation test</b>");
+ evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_box_pack_end(bx, lb);
+ evas_object_show(lb);
+
+ ad->wm_rot_supported = elm_win_wm_rotation_supported_get(win);
+ if (ad->wm_rot_supported)
+ {
+ int rots[] = { 0, 90, 270 };
+ elm_win_wm_rotation_available_rotations_set(win, rots, (sizeof(rots) / sizeof(int)));
+ elm_win_wm_rotation_preferred_rotation_set(win, 90);
+
+ bx2 = elm_box_add(win);
+ evas_object_size_hint_weight_set(bx2, EVAS_HINT_EXPAND, 0.0);
+ evas_object_size_hint_align_set(bx2, EVAS_HINT_FILL, 0.0);
+ elm_box_align_set(bx2, 0.0, 0.5);
+ elm_box_horizontal_set(bx2, EINA_TRUE);
+ elm_box_pack_end(bx, bx2);
+ evas_object_show(bx2);
+
+ for (i = 0; i < 4; i++)
+ {
+ ch = elm_check_add(win);
+ eina_convert_itoa((i * 90), buf);
+ elm_object_text_set(ch, eina_stringshare_add(buf));
+ evas_object_size_hint_weight_set(ch, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_box_pack_end(bx2, ch);
+ evas_object_show(ch);
+
+ if (i != 2) elm_check_state_set(ch, EINA_TRUE);
+
+ ad->chs = eina_list_append(ad->chs, ch);
+ }
+
+ bt = elm_button_add(win);
+ elm_object_text_set(bt, "Available rotations");
+ evas_object_smart_callback_add(bt, "clicked", _bt_available_rots_set, win);
+ elm_box_pack_end(bx, bt);
+ evas_object_show(bt);
+
+ bx2 = elm_box_add(win);
+ evas_object_size_hint_weight_set(bx2, EVAS_HINT_EXPAND, 0.0);
+ evas_object_size_hint_align_set(bx2, EVAS_HINT_FILL, 0.0);
+ elm_box_align_set(bx2, 0.0, 0.5);
+ elm_box_horizontal_set(bx2, EINA_TRUE);
+ elm_box_pack_end(bx, bx2);
+ evas_object_show(bx2);
+
+ for (i = 0; i < 5; i++)
+ {
+ rd = elm_radio_add(win);
+ if (!rdg) rdg = rd;
+ elm_radio_state_value_set(rd, i);
+ elm_radio_group_add(rd, rdg);
+
+ if (i == 0)
+ elm_object_text_set(rd, "Unset");
+ else
+ {
+ eina_convert_itoa(((i - 1) * 90), buf);
+ elm_object_text_set(rd, eina_stringshare_add(buf));
+ }
+
+ evas_object_size_hint_weight_set(rd, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_box_pack_end(bx2, rd);
+ evas_object_show(rd);
+ }
+
+ elm_radio_value_set(rdg, 2);
+ ad->rdg = rdg;
+
+ bt = elm_button_add(win);
+ elm_object_text_set(bt, "Preferred rotation");
+ evas_object_smart_callback_add(bt, "clicked", _bt_preferred_rot_set, win);
+ elm_box_pack_end(bx, bt);
+ evas_object_show(bt);
+
+ evas_object_smart_callback_add(win, "wm,rotation,changed", _win_wm_rotation_changed_cb, win);
+ }
+ else
+ printf("Window manager doesn't support rotation\n");
+
+ en = elm_entry_add(win);
+ elm_entry_single_line_set(en, EINA_TRUE);
+ evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
+ elm_box_pack_end(bx, en);
+ evas_object_show(en);
+
+ lb = elm_label_add(win);
+ elm_object_text_set(lb, "N/A");
+ evas_object_size_hint_weight_set(lb, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ elm_box_pack_end(bx, lb);
+ evas_object_show(lb);
+ ad->lb = lb;
+
+ evas_object_smart_callback_add(win, "delete,request", _win_del_cb, NULL);
+
+ evas_object_resize(win, 480, 400);
+ evas_object_show(bx);
+ evas_object_show(win);
+}
const char **available_list;
unsigned int count;
} profile;
+ struct
+ {
+ int preferred_rot; /* indicates preferred rotation value, -1 means invalid. */
+ int *rots; /* indicates available rotations */
+ unsigned int count; /* number of elements in available rotations */
+ Eina_Bool wm_supported : 1; /* set true when the window manager support window rotation */
+ Eina_Bool use : 1; /* set ture when application use window manager rotation. */
+ } wm_rot;
void *trap_data;
static const char SIG_PROFILE_CHANGED[] = "profile,changed";
static const char SIG_FOCUSED[] = "focused";
static const char SIG_UNFOCUSED[] = "unfocused";
+static const char SIG_WM_ROTATION_CHANGED[] = "wm,rotation,changed";
static const Evas_Smart_Cb_Description _smart_callbacks[] = {
{SIG_DELETE_REQUEST, ""},
{SIG_PROFILE_CHANGED, ""},
{SIG_FOCUSED, ""},
{SIG_UNFOCUSED, ""},
+ {SIG_WM_ROTATION_CHANGED, ""},
{NULL, NULL}
};
Evas *e,
Evas_Object *obj,
void *event_info);
+#ifdef HAVE_ELEMENTARY_X
+static void _elm_win_xwin_update(Elm_Win_Smart_Data *sd);
+#endif
EAPI double _elm_startup_time = 0;
Eina_Bool ch_fullscreen = EINA_FALSE;
Eina_Bool ch_maximized = EINA_FALSE;
Eina_Bool ch_profile = EINA_FALSE;
+ Eina_Bool ch_wm_rotation = EINA_FALSE;
const char *profile;
EINA_SAFETY_ON_NULL_RETURN(sd);
profile = ecore_evas_window_profile_get(sd->ee);
ch_profile = _elm_win_profile_set(sd, profile);
+ if (sd->wm_rot.use)
+ {
+ if (sd->rot != ecore_evas_rotation_get(sd->ee))
+ {
+ sd->rot = ecore_evas_rotation_get(sd->ee);
+ ch_wm_rotation = EINA_TRUE;
+ }
+ }
+
_elm_win_state_eval_queue();
if ((ch_withdrawn) || (ch_iconified))
{
_elm_win_profile_update(sd);
}
+ if (ch_wm_rotation)
+ {
+ evas_object_size_hint_min_set(obj, -1, -1);
+ evas_object_size_hint_max_set(obj, -1, -1);
+#ifdef HAVE_ELEMENTARY_X
+ _elm_win_xwin_update(sd);
+#endif
+ elm_widget_orientation_set(obj, sd->rot);
+ evas_object_smart_callback_call(obj, SIG_ROTATION_CHANGED, NULL);
+ evas_object_smart_callback_call(obj, SIG_WM_ROTATION_CHANGED, NULL);
+ }
}
static void
// do nothing
}
+ sd->wm_rot.wm_supported = ecore_evas_wm_rotation_supported_get(sd->ee);
+ sd->wm_rot.preferred_rot = -1; // it means that elm_win doesn't use preferred rotation.
+
sd->layout = edje_object_add(sd->evas);
_elm_theme_object_set(obj, sd->layout, "win", "base", "default");
sd->box = evas_object_box_add(sd->evas);
*ret = sd->rot;
}
+EAPI Eina_Bool
+elm_win_wm_rotation_supported_get(const Evas_Object *obj)
+{
+ ELM_WIN_CHECK(obj) EINA_FALSE;
+ Eina_Bool ret = EINA_FALSE;
+ eo_do((Eo *) obj, elm_obj_win_wm_rotation_supported_get(&ret));
+ return ret;
+}
+
+static void
+_wm_rotation_supported_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+ Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+ Elm_Win_Smart_Data *sd = _pd;
+ *ret = sd->wm_rot.wm_supported;
+}
+
+/* This will unset a preferred rotation, if given preferred rotation is '-1'.
+ */
+EAPI void
+elm_win_wm_rotation_preferred_rotation_set(const Evas_Object *obj,
+ int rotation)
+{
+ ELM_WIN_CHECK(obj);
+ eo_do((Eo *) obj, elm_obj_win_wm_preferred_rotation_set(rotation));
+}
+
+static void
+_wm_preferred_rotation_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+ int rotation = va_arg(*list, int);
+ int rot;
+ Elm_Win_Smart_Data *sd = _pd;
+
+ if (!sd->wm_rot.use)
+ sd->wm_rot.use = EINA_TRUE;
+
+ // '-1' means that elm_win doesn't use preferred rotation.
+ if (rotation == -1)
+ rot = -1;
+ else
+ rot = _win_rotation_degree_check(rotation);
+
+ if (sd->wm_rot.preferred_rot == rot) return;
+ sd->wm_rot.preferred_rot = rot;
+
+ ecore_evas_wm_rotation_preferred_rotation_set(sd->ee, rot);
+}
+
+EAPI int
+elm_win_wm_rotation_preferred_rotation_get(const Evas_Object *obj)
+{
+ ELM_WIN_CHECK(obj) -1;
+ int ret = -1;
+ eo_do((Eo *) obj, elm_obj_win_wm_preferred_rotation_get(&ret));
+ return ret;
+}
+
+static void
+_wm_preferred_rotation_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+ int *ret = va_arg(*list, int *);
+ Elm_Win_Smart_Data *sd = _pd;
+ *ret = sd->wm_rot.preferred_rot;
+}
+
+EAPI void
+elm_win_wm_rotation_available_rotations_set(Evas_Object *obj,
+ const int *rotations,
+ unsigned int count)
+{
+ ELM_WIN_CHECK(obj);
+ eo_do((Eo *) obj, elm_obj_win_wm_available_rotations_set(rotations, count));
+}
+
+static void
+_wm_available_rotations_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+ const int *rotations = va_arg(*list, const int *);
+ unsigned int count = va_arg(*list, unsigned int);
+ Elm_Win_Smart_Data *sd = _pd;
+ unsigned int i;
+ int r;
+
+ if (!sd->wm_rot.use)
+ sd->wm_rot.use = EINA_TRUE;
+
+ ELM_SAFE_FREE(sd->wm_rot.rots, free);
+ sd->wm_rot.count = 0;
+
+ if (count > 0)
+ {
+ sd->wm_rot.rots = calloc(count, sizeof(int));
+ if (!sd->wm_rot.rots) return;
+ for (i = 0; i < count; i++)
+ {
+ r = _win_rotation_degree_check(rotations[i]);
+ sd->wm_rot.rots[i] = r;
+ }
+ }
+
+ sd->wm_rot.count = count;
+
+ ecore_evas_wm_rotation_available_rotations_set(sd->ee,
+ sd->wm_rot.rots,
+ sd->wm_rot.count);
+}
+
+EAPI Eina_Bool
+elm_win_wm_rotation_available_rotations_get(const Evas_Object *obj,
+ int **rotations,
+ unsigned int *count)
+{
+ ELM_WIN_CHECK(obj) EINA_FALSE;
+ Eina_Bool ret = EINA_FALSE;
+ eo_do((Eo *) obj, elm_obj_win_wm_available_rotations_get(rotations, count, &ret));
+ return ret;
+}
+
+static void
+_wm_available_rotations_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+ int **rotations = va_arg(*list, int **);
+ unsigned int *count = va_arg(*list, unsigned int *);
+ Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+ Elm_Win_Smart_Data *sd = _pd;
+ *ret = EINA_FALSE;
+ if (!sd->wm_rot.use) return;
+
+ if (sd->wm_rot.count > 0)
+ {
+ if (rotations)
+ {
+ *rotations = calloc(sd->wm_rot.count, sizeof(int));
+ if (*rotations)
+ {
+ memcpy(*rotations,
+ sd->wm_rot.rots,
+ sizeof(int) * sd->wm_rot.count);
+ }
+ }
+ }
+
+ if (count) *count = sd->wm_rot.count;
+ *ret = EINA_TRUE;
+}
+
+EAPI void
+elm_win_wm_rotation_manual_rotation_done_set(Evas_Object *obj,
+ Eina_Bool set)
+{
+ ELM_WIN_CHECK(obj);
+ eo_do((Eo *) obj, elm_obj_win_wm_manual_rotation_done_set(set));
+}
+
+static void
+_wm_manual_rotation_done_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+ int set = va_arg(*list, int);
+ Elm_Win_Smart_Data *sd = _pd;
+ if (!sd->wm_rot.use) return;
+ ecore_evas_wm_rotation_manual_rotation_done_set(sd->ee, set);
+}
+
+EAPI Eina_Bool
+elm_win_wm_rotation_manual_rotation_done_get(const Evas_Object *obj)
+{
+ ELM_WIN_CHECK(obj) EINA_FALSE;
+ Eina_Bool ret = EINA_FALSE;
+ eo_do((Eo *) obj, elm_obj_win_wm_manual_rotation_done_get(&ret));
+ return ret;
+}
+
+static void
+_wm_manual_rotation_done_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+ Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+ Elm_Win_Smart_Data *sd = _pd;
+ if (!sd->wm_rot.use) return;
+ *ret = ecore_evas_wm_rotation_manual_rotation_done_get(sd->ee);
+}
+
+EAPI void
+elm_win_wm_rotation_manual_rotation_done(Evas_Object *obj)
+{
+ ELM_WIN_CHECK(obj);
+ eo_do((Eo *) obj, elm_obj_win_wm_manual_rotation_done());
+}
+
+static void
+_wm_manual_rotation_done(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
+{
+ Elm_Win_Smart_Data *sd = _pd;
+ if (!sd->wm_rot.use) return;
+ ecore_evas_wm_rotation_manual_rotation_done(sd->ee);
+}
+
EAPI void
elm_win_sticky_set(Evas_Object *obj,
Eina_Bool sticky)
EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_XWINDOW_GET), _xwindow_get),
EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WL_WINDOW_GET), _wl_window_get),
EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WINDOW_ID_GET), _window_id_get),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_ROTATION_SUPPORTED_GET), _wm_rotation_supported_get),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_SET), _wm_preferred_rotation_set),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_GET), _wm_preferred_rotation_get),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_SET), _wm_available_rotations_set),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_GET), _wm_available_rotations_get),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_SET), _wm_manual_rotation_done_set),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_GET), _wm_manual_rotation_done_get),
+ EO_OP_FUNC(ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE), _wm_manual_rotation_done),
+
EO_OP_FUNC_SENTINEL
};
EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_XWINDOW_GET, "Get the Ecore_X_Window of an Evas_Object."),
EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WL_WINDOW_GET, "Get the Ecore_Wl_Window of an Evas_Object."),
EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WINDOW_ID_GET, "Get the Ecore_Window of an Evas_Object."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_ROTATION_SUPPORTED_GET, "Query if the underlying windowing system supports the window manager rotation.."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_SET, "Set the preferred rotation hint."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_GET, "Get the preferred rotation hint."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_SET, "Set the array of available window rotations."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_GET, "Get the array of available window rotations."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_SET, "Set manual rotation done mode of obj window."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_GET, "Get manual rotation done mode of obj window."),
+ EO_OP_DESCRIPTION(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE, "Set rotation finish manually"),
EO_OP_DESCRIPTION_SENTINEL
};
ELM_OBJ_WIN_SUB_ID_XWINDOW_GET,
ELM_OBJ_WIN_SUB_ID_WL_WINDOW_GET,
ELM_OBJ_WIN_SUB_ID_WINDOW_ID_GET,
+ ELM_OBJ_WIN_SUB_ID_WM_ROTATION_SUPPORTED_GET,
+ ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_SET,
+ ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_GET,
+ ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_SET,
+ ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_GET,
+ ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_SET,
+ ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_GET,
+ ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE,
ELM_OBJ_WIN_SUB_ID_LAST
};
#define elm_obj_win_window_id_get(ret) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WINDOW_ID_GET), EO_TYPECHECK(Ecore_Window *, ret)
/**
- * @}
+ * @def elm_obj_win_wm_rotation_supported_get
+ * @since 1.9
+ *
+ * Query whether window manager supports window rotation or not.
+ *
+ * @param[out] ret
+ *
+ * @see elm_win_wm_rotation_supported_get
+ */
+#define elm_obj_win_wm_rotation_supported_get(ret) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_ROTATION_SUPPORTED_GET), EO_TYPECHECK(Eina_Bool *, ret)
+
+/**
+ * @def elm_obj_win_wm_preferred_rotation_set
+ * @since 1.9
+ *
+ * Set the preferred rotation value.
+ *
+ * @param[in] rotation
+ *
+ * @see elm_win_wm_rotation_preferred_rotation_set
+ */
+#define elm_obj_win_wm_preferred_rotation_set(rotation) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_SET), EO_TYPECHECK(int, rotation)
+
+/**
+ * @def elm_obj_win_wm_preferred_rotation_get
+ * @since 1.9
+ *
+ * Get the preferred rotation value.
+ *
+ * @param[out] ret
+ *
+ * @see elm_win_wm_rotation_preferred_rotation_get
+ */
+#define elm_obj_win_wm_preferred_rotation_get(ret) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_PREFERRED_ROTATION_GET), EO_TYPECHECK(int *, ret)
+
+/**
+ * @def elm_obj_win_wm_available_rotations_set
+ * @since 1.9
+ *
+ * Set the array of available rotations.
+ *
+ * @param[in] rotations
+ * @param[in] count
+ *
+ * @see elm_win_wm_rotation_available_rotations_set
*/
+#define elm_obj_win_wm_available_rotations_set(rotation, count) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_SET), EO_TYPECHECK(const int *, rotations), EO_TYPECHECK(unsigned int, count)
+/**
+ * @def elm_obj_win_wm_available_rotations_get
+ * @since 1.9
+ *
+ * Get the array of available window rotation value.
+ *
+ * @param[out] rotations
+ * @param[out] count
+ * @param[out] ret
+ *
+ * @see elm_win_wm_rotation_available_rotations_get
+ */
+#define elm_obj_win_wm_available_rotations_get(rotations, count, ret) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_AVAILABLE_ROTATIONS_GET), EO_TYPECHECK(int **, rotations), EO_TYPECHECK(unsigned int *, count), EO_TYPECHECK(Eina_Bool *, ret)
+
+/**
+ * @def elm_obj_win_wm_manual_rotation_done_set
+ * @since 1.9
+ *
+ * Set manual rotation done mode
+ *
+ * @param[in] set
+ *
+ * @see elm_win_wm_rotation_manual_rotation_done_set
+ */
+#define elm_obj_win_wm_manual_rotation_done_set(set) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_SET), EO_TYPECHECK(Eina_Bool, set)
+
+/**
+ * @def elm_obj_win_wm_manual_rotation_done_get
+ * @since 1.9
+ *
+ * Get manual rotation done mode state
+ *
+ * @param[out] ret
+ *
+ * @see elm_win_wm_rotation_manual_rotation_done_get
+ */
+#define elm_obj_win_wm_manual_rotation_done_get(ret) ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE_GET), EO_TYPECHECK(Eina_Bool *, ret)
+
+/**
+ * @def elm_obj_win_wm_manual_rotation_done
+ * @since 1.9
+ *
+ * Set rotation finish manually
+ *
+ * @see elm_win_wm_rotation_manual_rotation_done
+ */
+#define elm_obj_win_wm_manual_rotation_done() ELM_OBJ_WIN_ID(ELM_OBJ_WIN_SUB_ID_WM_MANUAL_ROTATION_DONE)
*/
EAPI int elm_win_rotation_get(const Evas_Object *obj);
+/**
+ * Query whether window manager supports window rotation or not.
+ *
+ * The window manager rotation allows the WM to controls the rotation of application windows.
+ * It is designed to support synchronized rotation for the multiple application windows at same time.
+ *
+ * @return @c EINA_TRUE if the window manager rotation is supported, @c EINA_FALSE otherwise.
+ *
+ * @see elm_win_wm_rotation_supported_get()
+ * @see elm_win_wm_rotation_preferred_rotation_set()
+ * @see elm_win_wm_rotation_preferred_rotation_get()
+ * @see elm_win_wm_rotation_available_rotations_set()
+ * @see elm_win_wm_rotation_available_rotations_get()
+ * @see elm_win_wm_rotation_manual_rotation_done_set()
+ * @see elm_win_wm_rotation_manual_rotation_done_get()
+ * @see elm_win_wm_rotation_manual_rotation_done()
+ *
+ * @ingroup Win
+ * @since 1.9
+ */
+EAPI Eina_Bool elm_win_wm_rotation_supported_get(const Evas_Object *obj);
+
+/**
+ * Set the preferred rotation value.
+ *
+ * This function is used to set the orientation of window @p obj to spicific angle fixed.
+ *
+ * @param obj The window object
+ * @param rotation The preferred rotation of the window in degrees (0-360),
+ * counter-clockwise.
+ *
+ * @see elm_win_wm_rotation_preferred_rotation_get()
+ *
+ * ingroup Win
+ * @since 1.9
+ */
+EAPI void elm_win_wm_rotation_preferred_rotation_set(const Evas_Object *obj, int rotation);
+
+/**
+ * Get the preferred rotation value.
+ *
+ * This function is used to get the preferred rotoation value.
+ *
+ * @param obj The window object
+ * @return The preferred rotation of the window in degrees (0-360),
+ * counter-clockwise.
+ *
+ * @see elm_win_wm_rotation_preferred_rotation_set()
+ *
+ * ingroup Win
+ * @since 1.9
+ */
+EAPI int elm_win_wm_rotation_preferred_rotation_get(const Evas_Object *obj);
+
+/**
+ * Set the array of available window rotations.
+ *
+ * This function is used to set the available rotations to give the hints to WM.
+ * WM will refer this hints and set the orientation window properly.
+ *
+ * @param obj The window object
+ * @param *rotations The array of rotation value.
+ * @param count The number of array of rotations
+ *
+ * @see elm_win_wm_rotation_available_rotations_get()
+ *
+ * ingroup Win
+ * @since 1.9
+ */
+EAPI void elm_win_wm_rotation_available_rotations_set(Evas_Object *obj, const int *rotations, unsigned int count);
+
+/**
+ * Get the array of available window rotations.
+ *
+ * This function is used to get the available rotations.
+ *
+ * @param obj The window object
+ * @param rotations To store the available rotations.
+ * @param count To store the number of rotations.
+ *
+ * @see elm_win_wm_rotation_available_rotations_set()
+ *
+ * ingroup Win
+ * @since 1.9
+ */
+EAPI Eina_Bool elm_win_wm_rotation_available_rotations_get(const Evas_Object *obj, int **rotations, unsigned int *count);
+
+/**
+ * Set the manual rotation done mode.
+ *
+ * This function is used to set or reset the manual rotation done mode.
+ * the message of rotation done is sent to WM after rendering its canvas in Ecore_Evas.
+ * but if set the manual rotation done mode,
+ * it's disabled and user should call the "elm_win_wm_rotation_manual_done" explicitly to sends the message.
+ *
+ * @param obj The window object
+ * @param set EINA_TRUE means to set manual rotation done mode EINA_FALSE otherwise.
+ *
+ * @see elm_win_wm_rotation_manual_rotation_done_get()
+ * @see elm_win_wm_rotation_manual_rotation_done()
+ *
+ * ingroup Win
+ * @since 1.9
+ */
+EAPI void elm_win_wm_rotation_manual_rotation_done_set(Evas_Object *obj, Eina_Bool set);
+
+/**
+ * Get the state of manual rotation done mode.
+ *
+ * This function is used to get the state of manual rotation done mode.
+ *
+ * @param obj The window object
+ * @return @c EINA_TRUE manual rotationn done mode, @c EINA_FALSE otherwise.
+ *
+ * @see elm_win_wm_rotation_manual_rotation_done_set()
+ * @see elm_win_wm_rotation_manual_rotation_done()
+ *
+ * ingroup Win
+ * @since 1.9
+ */
+EAPI Eina_Bool elm_win_wm_rotation_manual_rotation_done_get(const Evas_Object *obj);
+
+/**
+ * To notify the rotation done to WM manually.
+ *
+ * This function is used to notify the rotation done to WM manually.
+ *
+ * @param obj The window object
+ *
+ * @see elm_win_wm_rotation_manual_rotation_done_set()
+ * @see elm_win_wm_rotation_manual_rotation_done_get()
+ *
+ * ingroup Win
+ * @since 1.9
+ */
+EAPI void elm_win_wm_rotation_manual_rotation_done(Evas_Object *obj);
+
/**
* Set the sticky state of the window.
*
projects / platform / upstream / elementary.git / commitdiff