2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2014-10-17 08:56:11 -07:00
|
|
|
#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
|
|
|
|
|
2009-12-01 23:22:35 -08:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
2016-06-06 16:50:26 -07:00
|
|
|
#include "efl_ui_widget_flip.h"
|
2012-11-25 22:32:53 -08:00
|
|
|
#include "elm_widget_container.h"
|
2009-12-01 23:22:35 -08:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
#include "efl_ui_flip_internal_part.eo.h"
|
2016-05-24 04:40:18 -07:00
|
|
|
#include "elm_part_helper.h"
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
#define MY_CLASS EFL_UI_FLIP_CLASS
|
2016-07-12 02:03:54 -07:00
|
|
|
#define MY_CLASS_NAME "Efl.Ui.Flip"
|
2013-11-07 03:44:22 -08:00
|
|
|
#define MY_CLASS_NAME_LEGACY "elm_flip"
|
2009-12-01 23:22:35 -08:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
static const char SIG_ANIMATE_BEGIN[] = "animate,begin";
|
2011-04-03 09:26:25 -07:00
|
|
|
static const char SIG_ANIMATE_DONE[] = "animate,done";
|
2012-05-15 10:37:42 -07:00
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] = {
|
2011-05-25 03:20:49 -07:00
|
|
|
{SIG_ANIMATE_BEGIN, ""},
|
2011-04-03 09:26:25 -07:00
|
|
|
{SIG_ANIMATE_DONE, ""},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
static Eina_Bool _flip(Evas_Object *obj);
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
static void _update_front_back(Eo *obj, Efl_Ui_Flip_Data *sd);
|
|
|
|
|
2009-12-01 23:22:35 -08:00
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_free(Slice *sl)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_del(sl->obj);
|
|
|
|
free(sl);
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_state_slices_clear(Efl_Ui_Flip_Data *sd)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
int i, j, num;
|
2009-12-01 23:22:35 -08:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->slices)
|
|
|
|
{
|
|
|
|
num = 0;
|
|
|
|
for (j = 0; j < sd->slices_h; j++)
|
|
|
|
{
|
|
|
|
for (i = 0; i < sd->slices_w; i++)
|
|
|
|
{
|
|
|
|
if (sd->slices[num]) _slice_free(sd->slices[num]);
|
|
|
|
if (sd->slices2[num]) _slice_free(sd->slices2[num]);
|
|
|
|
num++;
|
|
|
|
}
|
|
|
|
}
|
2010-10-01 12:03:02 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
free(sd->slices);
|
|
|
|
free(sd->slices2);
|
|
|
|
sd->slices = NULL;
|
|
|
|
sd->slices2 = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sd->slices_w = 0;
|
|
|
|
sd->slices_h = 0;
|
2010-10-01 12:03:02 -07:00
|
|
|
}
|
|
|
|
|
2009-12-01 23:22:35 -08:00
|
|
|
static void
|
|
|
|
_sizing_eval(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Coord minw = -1, minh = -1, minw2 = -1, minh2 = -1;
|
|
|
|
Evas_Coord maxw = -1, maxh = -1, maxw2 = -1, maxh2 = -1;
|
2011-05-24 23:06:48 -07:00
|
|
|
int fingx = 0, fingy = 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
if (sd->front.content)
|
2016-06-09 00:29:40 -07:00
|
|
|
efl_gfx_size_hint_combined_min_get(sd->front.content, &minw, &minh);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->back.content)
|
2016-06-09 00:29:40 -07:00
|
|
|
efl_gfx_size_hint_combined_min_get(sd->back.content, &minw2, &minh2);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->front.content)
|
|
|
|
evas_object_size_hint_max_get(sd->front.content, &maxw, &maxh);
|
|
|
|
if (sd->back.content)
|
|
|
|
evas_object_size_hint_max_get(sd->back.content, &maxw2, &maxh2);
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2009-12-01 23:22:35 -08:00
|
|
|
if (minw2 > minw) minw = minw2;
|
|
|
|
if (minh2 > minh) minh = minh2;
|
|
|
|
if ((maxw2 >= 0) && (maxw2 < maxw)) maxw = maxw2;
|
|
|
|
if ((maxh2 >= 0) && (maxh2 < maxh)) maxh = maxh2;
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2013-07-26 04:03:26 -07:00
|
|
|
if (sd->dir_enabled[ELM_FLIP_DIRECTION_UP]) fingy++;
|
|
|
|
if (sd->dir_enabled[ELM_FLIP_DIRECTION_DOWN]) fingy++;
|
|
|
|
if (sd->dir_enabled[ELM_FLIP_DIRECTION_LEFT]) fingx++;
|
|
|
|
if (sd->dir_enabled[ELM_FLIP_DIRECTION_RIGHT]) fingx++;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
elm_coords_finger_size_adjust(fingx, &minw, fingy, &minh);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2009-12-01 23:22:35 -08:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
evas_object_size_hint_max_set(obj, maxw, maxh);
|
|
|
|
}
|
|
|
|
|
theme: return enum from elm_widget_style_set instead of bool
Summary:
if trying to apply incorrect theme, widget apply default theme and return TRUE.
so there is no way to check it really apply correct theme.
To resolve this problem, _elm_theme_set return three type enum
* related history : 4ca3ef45146e05908a13d1010909abeba9693ad6
* elm_object_style_set is public api, so I didn't change it.
* typedef name [ Theme_Apply ] is temporarily, please suggest better one.
@fix
Reviewers: singh.amitesh, herb, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4073
2016-06-30 23:09:42 -07:00
|
|
|
EOLIAN static Elm_Theme_Apply
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_elm_widget_theme_apply(Eo *obj, Efl_Ui_Flip_Data *sd EINA_UNUSED)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
theme: return enum from elm_widget_style_set instead of bool
Summary:
if trying to apply incorrect theme, widget apply default theme and return TRUE.
so there is no way to check it really apply correct theme.
To resolve this problem, _elm_theme_set return three type enum
* related history : 4ca3ef45146e05908a13d1010909abeba9693ad6
* elm_object_style_set is public api, so I didn't change it.
* typedef name [ Theme_Apply ] is temporarily, please suggest better one.
@fix
Reviewers: singh.amitesh, herb, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4073
2016-06-30 23:09:42 -07:00
|
|
|
Elm_Theme_Apply int_ret = ELM_THEME_APPLY_FAILED;
|
2016-08-15 06:44:41 -07:00
|
|
|
int_ret = elm_obj_widget_theme_apply(efl_super(obj, MY_CLASS));
|
theme: return enum from elm_widget_style_set instead of bool
Summary:
if trying to apply incorrect theme, widget apply default theme and return TRUE.
so there is no way to check it really apply correct theme.
To resolve this problem, _elm_theme_set return three type enum
* related history : 4ca3ef45146e05908a13d1010909abeba9693ad6
* elm_object_style_set is public api, so I didn't change it.
* typedef name [ Theme_Apply ] is temporarily, please suggest better one.
@fix
Reviewers: singh.amitesh, herb, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4073
2016-06-30 23:09:42 -07:00
|
|
|
if (!int_ret) return ELM_THEME_APPLY_FAILED;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
_sizing_eval(obj);
|
|
|
|
|
theme: return enum from elm_widget_style_set instead of bool
Summary:
if trying to apply incorrect theme, widget apply default theme and return TRUE.
so there is no way to check it really apply correct theme.
To resolve this problem, _elm_theme_set return three type enum
* related history : 4ca3ef45146e05908a13d1010909abeba9693ad6
* elm_object_style_set is public api, so I didn't change it.
* typedef name [ Theme_Apply ] is temporarily, please suggest better one.
@fix
Reviewers: singh.amitesh, herb, Hermet, cedric, jpeg, raster
Subscribers: cedric, jpeg
Differential Revision: https://phab.enlightenment.org/D4073
2016-06-30 23:09:42 -07:00
|
|
|
return int_ret;
|
2012-05-15 10:37:42 -07:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_elm_widget_focus_next_manager_is(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *_pd EINA_UNUSED)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
2014-03-23 02:14:48 -07:00
|
|
|
return EINA_TRUE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_elm_widget_focus_next(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Elm_Focus_Direction dir, Evas_Object **next, Elm_Object_Item **next_item)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
/* attempt to cycle focus on in sub-items */
|
|
|
|
if (sd->state)
|
2015-09-15 03:41:51 -07:00
|
|
|
return elm_widget_focus_next_get(sd->front.content, dir, next, next_item);
|
2012-05-15 10:37:42 -07:00
|
|
|
else
|
2015-09-15 03:41:51 -07:00
|
|
|
return elm_widget_focus_next_get(sd->back.content, dir, next, next_item);
|
2012-05-15 10:37:42 -07:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_elm_widget_focus_direction_manager_is(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *_pd EINA_UNUSED)
|
2013-09-11 09:16:58 -07:00
|
|
|
{
|
|
|
|
if (!elm_widget_can_focus_get(obj))
|
2014-03-23 02:14:48 -07:00
|
|
|
return EINA_TRUE;
|
2013-09-11 09:16:58 -07:00
|
|
|
else
|
2014-03-23 02:14:48 -07:00
|
|
|
return EINA_FALSE;
|
2013-09-11 09:16:58 -07:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_elm_widget_focus_direction(Eo *obj, Efl_Ui_Flip_Data *sd, const Evas_Object *base, double degree, Evas_Object **direction, Elm_Object_Item **direction_item, double *weight)
|
2013-09-11 09:16:58 -07:00
|
|
|
{
|
2014-03-23 02:14:48 -07:00
|
|
|
Eina_Bool ret;
|
2013-09-11 09:16:58 -07:00
|
|
|
|
|
|
|
Eina_List *l = NULL;
|
|
|
|
void *(*list_data_get)(const Eina_List *list);
|
|
|
|
|
|
|
|
list_data_get = eina_list_data_get;
|
|
|
|
|
|
|
|
if (sd->front.content)
|
|
|
|
l = eina_list_append(l, sd->front.content);
|
|
|
|
if (sd->back.content)
|
|
|
|
l = eina_list_append(l, sd->back.content);
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
ret = elm_widget_focus_list_direction_get
|
2015-09-24 23:24:53 -07:00
|
|
|
(obj, base, l, list_data_get, degree, direction, direction_item, weight);
|
2013-09-11 09:16:58 -07:00
|
|
|
|
|
|
|
eina_list_free(l);
|
2014-03-23 02:14:48 -07:00
|
|
|
|
|
|
|
return ret;
|
2013-09-11 09:16:58 -07:00
|
|
|
}
|
|
|
|
|
2009-12-01 23:22:35 -08:00
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_changed_size_hints_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
|
|
|
_sizing_eval(data);
|
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_elm_widget_sub_object_add(Eo *obj, Efl_Ui_Flip_Data *_pd EINA_UNUSED, Evas_Object *sobj)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
2014-04-03 08:04:11 -07:00
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2013-01-03 01:52:57 -08:00
|
|
|
if (evas_object_data_get(sobj, "elm-parent") == obj)
|
2014-03-23 02:14:48 -07:00
|
|
|
return EINA_TRUE;
|
2013-01-03 01:52:57 -08:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
int_ret = elm_obj_widget_sub_object_add(efl_super(obj, MY_CLASS), sobj);
|
2014-03-23 02:14:48 -07:00
|
|
|
if (!int_ret) return EINA_FALSE;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2012-08-08 03:12:19 -07:00
|
|
|
evas_object_data_set(sobj, "_elm_leaveme", sobj);
|
2012-08-02 01:42:06 -07:00
|
|
|
evas_object_smart_member_add(sobj, obj);
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_event_callback_add
|
|
|
|
(sobj, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints_cb, obj);
|
2016-07-19 22:24:23 -07:00
|
|
|
evas_object_lower(sobj);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
return EINA_TRUE;
|
2012-05-15 10:37:42 -07:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_elm_widget_sub_object_del(Eo *obj, Efl_Ui_Flip_Data *sd, Evas_Object *sobj)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
2014-04-03 08:04:11 -07:00
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
int_ret = elm_obj_widget_sub_object_del(efl_super(obj, MY_CLASS), sobj);
|
2014-03-23 02:14:48 -07:00
|
|
|
if (!int_ret) return EINA_FALSE;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
if (sobj == sd->front.content)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
2012-08-08 03:12:19 -07:00
|
|
|
evas_object_data_del(sobj, "_elm_leaveme");
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->front.content = NULL;
|
|
|
|
evas_object_hide(sd->front.clip);
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
else if (sobj == sd->back.content)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
2012-08-08 03:12:19 -07:00
|
|
|
evas_object_data_del(sobj, "_elm_leaveme");
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->back.content = NULL;
|
|
|
|
evas_object_hide(sd->back.clip);
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
evas_object_smart_member_del(sobj);
|
|
|
|
evas_object_clip_unset(sobj);
|
|
|
|
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(sobj, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints_cb, obj);
|
|
|
|
_sizing_eval(obj);
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
return EINA_TRUE;
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
static Slice *
|
2012-11-25 22:32:53 -08:00
|
|
|
_slice_new(Evas_Object *container_obj,
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object *obj)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
Slice *sl;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
sl = calloc(1, sizeof(Slice));
|
|
|
|
if (!sl) return NULL;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
sl->obj = evas_object_image_add(evas_object_evas_get(obj));
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_object_smart_member_add(sl->obj, container_obj);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_object_image_smooth_scale_set(sl->obj, EINA_FALSE);
|
|
|
|
evas_object_pass_events_set(sl->obj, EINA_TRUE);
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_object_image_source_set(sl->obj, obj);
|
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
return sl;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_slice_apply(Efl_Ui_Flip_Data *sd,
|
2012-05-15 10:37:42 -07:00
|
|
|
Slice *sl,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Coord x EINA_UNUSED,
|
|
|
|
Evas_Coord y EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Coord w,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Coord h EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Coord ox,
|
|
|
|
Evas_Coord oy,
|
|
|
|
Evas_Coord ow,
|
|
|
|
Evas_Coord oh)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-01 23:53:38 -07:00
|
|
|
static Evas_Map *m = NULL;
|
2011-05-25 03:20:49 -07:00
|
|
|
int i;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-01 23:53:38 -07:00
|
|
|
if (!m) m = evas_map_new(4);
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!m) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_map_smooth_set(m, EINA_FALSE);
|
2011-05-25 03:20:49 -07:00
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
|
|
|
evas_map_point_color_set(m, i, 255, 255, 255, 255);
|
2013-07-26 04:56:24 -07:00
|
|
|
if (sd->dir == ELM_FLIP_DIRECTION_LEFT)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
int p[4] = { 0, 1, 2, 3 };
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_map_point_coord_set(m, i, ox + sl->x[p[i]], oy + sl->y[p[i]],
|
|
|
|
sl->z[p[i]]);
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_map_point_image_uv_set(m, i, sl->u[p[i]], sl->v[p[i]]);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_RIGHT)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
int p[4] = { 1, 0, 3, 2 };
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_map_point_coord_set(m, i, ox + (w - sl->x[p[i]]),
|
|
|
|
oy + sl->y[p[i]], sl->z[p[i]]);
|
|
|
|
evas_map_point_image_uv_set(m, i, ow - sl->u[p[i]], sl->v[p[i]]);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_UP)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
int p[4] = { 1, 0, 3, 2 };
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_map_point_coord_set(m, i, ox + sl->y[p[i]], oy + sl->x[p[i]],
|
|
|
|
sl->z[p[i]]);
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_map_point_image_uv_set(m, i, sl->v[p[i]], sl->u[p[i]]);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
else /* if (sd->dir == 3) will be this anyway */
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
int p[4] = { 0, 1, 2, 3 };
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_map_point_coord_set(m, i, ox + sl->y[p[i]],
|
|
|
|
oy + (w - sl->x[p[i]]), sl->z[p[i]]);
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_map_point_image_uv_set(m, i, sl->v[p[i]], oh - sl->u[p[i]]);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_object_map_enable_set(sl->obj, EINA_TRUE);
|
|
|
|
evas_object_image_fill_set(sl->obj, 0, 0, ow, oh);
|
|
|
|
evas_object_map_set(sl->obj, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_slice_3d(Efl_Ui_Flip_Data *sd EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Slice *sl,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y,
|
|
|
|
Evas_Coord w,
|
|
|
|
Evas_Coord h)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
Evas_Map *m = (Evas_Map *)evas_object_map_get(sl->obj);
|
|
|
|
int i;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!m) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
// vanishing point is center of page, and focal dist is 1024
|
|
|
|
evas_map_util_3d_perspective(m, x + (w / 2), y + (h / 2), 0, 1024);
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
2012-09-02 23:32:40 -07:00
|
|
|
Evas_Coord xx, yy;
|
|
|
|
evas_map_point_coord_get(m, i, &xx, &yy, NULL);
|
2012-03-07 00:05:42 -08:00
|
|
|
evas_map_point_coord_set(m, i, xx, yy, 0);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (evas_map_util_clockwise_get(m)) evas_object_show(sl->obj);
|
|
|
|
else evas_object_hide(sl->obj);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_object_map_set(sl->obj, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_slice_light(Efl_Ui_Flip_Data *sd EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Slice *sl,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y,
|
|
|
|
Evas_Coord w,
|
|
|
|
Evas_Coord h)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
Evas_Map *m = (Evas_Map *)evas_object_map_get(sl->obj);
|
|
|
|
int i;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!m) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_map_util_3d_lighting(m,
|
2012-05-15 10:37:42 -07:00
|
|
|
/* light position
|
|
|
|
* (centered over page 10 * h toward camera) */
|
|
|
|
x + (w / 2), y + (h / 2), -10000,
|
2011-05-25 03:20:49 -07:00
|
|
|
255, 255, 255, // light color
|
2012-05-15 10:37:42 -07:00
|
|
|
0, 0, 0); // ambient minimum
|
|
|
|
|
2014-02-04 21:37:46 -08:00
|
|
|
// multiply brightness by 1.2 to make lightish bits all white so we don't
|
2011-05-25 03:20:49 -07:00
|
|
|
// add shading where we could otherwise be pure white
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
|
|
|
int r, g, b, a;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_map_point_color_get(m, i, &r, &g, &b, &a);
|
|
|
|
r = (double)r * 1.2; if (r > 255) r = 255;
|
|
|
|
g = (double)g * 1.2; if (g > 255) g = 255;
|
|
|
|
b = (double)b * 1.2; if (b > 255) b = 255;
|
|
|
|
evas_map_point_color_set(m, i, r, g, b, a);
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_object_map_set(sl->obj, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_slice_xyz(Efl_Ui_Flip_Data *sd EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Slice *sl,
|
|
|
|
double xx1,
|
|
|
|
double yy1,
|
|
|
|
double zz1,
|
|
|
|
double xx2,
|
|
|
|
double yy2,
|
|
|
|
double zz2,
|
|
|
|
double xx3,
|
|
|
|
double yy3,
|
|
|
|
double zz3,
|
|
|
|
double xx4,
|
|
|
|
double yy4,
|
|
|
|
double zz4)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-03-07 00:05:42 -08:00
|
|
|
sl->x[0] = xx1; sl->y[0] = yy1; sl->z[0] = zz1;
|
|
|
|
sl->x[1] = xx2; sl->y[1] = yy2; sl->z[1] = zz2;
|
|
|
|
sl->x[2] = xx3; sl->y[2] = yy3; sl->z[2] = zz3;
|
|
|
|
sl->x[3] = xx4; sl->y[3] = yy4; sl->z[3] = zz4;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_slice_uv(Efl_Ui_Flip_Data *sd EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Slice *sl,
|
|
|
|
double u1,
|
|
|
|
double v1,
|
|
|
|
double u2,
|
|
|
|
double v2,
|
|
|
|
double u3,
|
|
|
|
double v3,
|
|
|
|
double u4,
|
|
|
|
double v4)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
sl->u[0] = u1; sl->v[0] = v1;
|
|
|
|
sl->u[1] = u2; sl->v[1] = v2;
|
|
|
|
sl->u[2] = u3; sl->v[2] = v3;
|
|
|
|
sl->u[3] = u4; sl->v[3] = v4;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_deform_point(Vertex2 *vi,
|
|
|
|
Vertex3 *vo,
|
|
|
|
double rho,
|
|
|
|
double theta,
|
|
|
|
double A)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
// ^Y
|
|
|
|
// |
|
|
|
|
// | X
|
|
|
|
// +---->
|
|
|
|
// theta == cone angle (0 -> PI/2)
|
|
|
|
// A == distance of cone apex from origin
|
|
|
|
// rho == angle of cone from vertical axis (...-PI/2 to PI/2...)
|
2012-05-15 10:37:42 -07:00
|
|
|
Vertex3 v1;
|
2011-05-25 03:20:49 -07:00
|
|
|
double d, r, b;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
d = sqrt((vi->x * vi->x) + pow(vi->y - A, 2));
|
|
|
|
r = d * sin(theta);
|
|
|
|
b = asin(vi->x / d) / sin(theta);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
v1.x = r * sin(b);
|
|
|
|
v1.y = d + A - (r * (1 - cos(b)) * sin(theta));
|
|
|
|
v1.z = r * (1 - cos(b)) * cos(theta);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
vo->x = (v1.x * cos(rho)) - (v1.z * sin(rho));
|
|
|
|
vo->y = v1.y;
|
|
|
|
vo->z = (v1.x * sin(rho)) + (v1.z * cos(rho));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_interp_point(Vertex3 *vi1,
|
|
|
|
Vertex3 *vi2,
|
|
|
|
Vertex3 *vo,
|
|
|
|
double v)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
vo->x = (v * vi2->x) + ((1.0 - v) * vi1->x);
|
|
|
|
vo->y = (v * vi2->y) + ((1.0 - v) * vi1->y);
|
|
|
|
vo->z = (v * vi2->z) + ((1.0 - v) * vi1->z);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_obj_color_sum(Slice *s,
|
|
|
|
int p,
|
|
|
|
int *r,
|
|
|
|
int *g,
|
|
|
|
int *b,
|
|
|
|
int *a)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
Evas_Map *m;
|
|
|
|
int rr = 0, gg = 0, bb = 0, aa = 0;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!s) return 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
m = (Evas_Map *)evas_object_map_get(s->obj);
|
|
|
|
if (!m) return 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_map_point_color_get(m, p, &rr, &gg, &bb, &aa);
|
|
|
|
*r += rr; *g += gg; *b += bb; *a += aa;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_obj_color_set(Slice *s,
|
|
|
|
int p,
|
|
|
|
int r,
|
|
|
|
int g,
|
|
|
|
int b,
|
|
|
|
int a)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
Evas_Map *m;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!s) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
m = (Evas_Map *)evas_object_map_get(s->obj);
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!m) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_map_point_color_set(m, p, r, g, b, a);
|
|
|
|
evas_object_map_set(s->obj, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_obj_vert_color_merge(Slice *s1,
|
|
|
|
int p1,
|
|
|
|
Slice *s2,
|
|
|
|
int p2,
|
|
|
|
Slice *s3,
|
|
|
|
int p3,
|
|
|
|
Slice *s4,
|
|
|
|
int p4)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
int r = 0, g = 0, b = 0, a = 0, n = 0;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
n += _slice_obj_color_sum(s1, p1, &r, &g, &b, &a);
|
|
|
|
n += _slice_obj_color_sum(s2, p2, &r, &g, &b, &a);
|
|
|
|
n += _slice_obj_color_sum(s3, p3, &r, &g, &b, &a);
|
|
|
|
n += _slice_obj_color_sum(s4, p4, &r, &g, &b, &a);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (n < 1) return;
|
|
|
|
r /= n; g /= n; b /= n; a /= n;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
_slice_obj_color_set(s1, p1, r, g, b, a);
|
|
|
|
_slice_obj_color_set(s2, p2, r, g, b, a);
|
|
|
|
_slice_obj_color_set(s3, p3, r, g, b, a);
|
|
|
|
_slice_obj_color_set(s4, p4, r, g, b, a);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2012-11-25 22:32:53 -08:00
|
|
|
_state_update(Evas_Object *obj)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Efl_Ui_Flip_Data *sd = efl_data_scope_get(obj, MY_CLASS);
|
2011-05-25 03:20:49 -07:00
|
|
|
Slice *sl;
|
2012-05-15 10:37:42 -07:00
|
|
|
Vertex3 *tvo, *tvol;
|
|
|
|
Evas_Object *front, *back;
|
|
|
|
int i, j, num, nn, jump, num2;
|
2011-05-25 03:20:49 -07:00
|
|
|
double b, minv = 0.0, minva, mgrad;
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Coord xx1, yy1, xx2, yy2, mx, my;
|
|
|
|
Evas_Coord x, y, w, h, ox, oy, ow, oh;
|
2011-05-25 03:20:49 -07:00
|
|
|
int gx, gy, gszw, gszh, gw, gh, col, row, nw, nh;
|
2014-01-06 07:09:44 -08:00
|
|
|
double rho, A, theta, perc, n, rhol, Al, thetal;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->backflip = EINA_TRUE;
|
|
|
|
if (sd->state)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
front = sd->front.content;
|
|
|
|
back = sd->front.content;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
front = sd->back.content;
|
|
|
|
back = sd->back.content;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
2011-05-25 03:20:49 -07:00
|
|
|
ox = x; oy = y; ow = w; oh = h;
|
2012-05-15 10:37:42 -07:00
|
|
|
xx1 = sd->down_x;
|
|
|
|
yy1 = sd->down_y;
|
|
|
|
xx2 = sd->x;
|
|
|
|
yy2 = sd->y;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2013-07-26 04:56:24 -07:00
|
|
|
if (sd->dir == ELM_FLIP_DIRECTION_LEFT)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
// no nothing. left drag is standard
|
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_RIGHT)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-03-07 00:11:00 -08:00
|
|
|
xx1 = (w - 1) - xx1;
|
|
|
|
xx2 = (w - 1) - xx2;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_UP)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
Evas_Coord tmp;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-03-07 00:11:00 -08:00
|
|
|
tmp = xx1; xx1 = yy1; yy1 = tmp;
|
|
|
|
tmp = xx2; xx2 = yy2; yy2 = tmp;
|
2011-05-25 03:20:49 -07:00
|
|
|
tmp = w; w = h; h = tmp;
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
else /* if (sd->dir == 3) will be this anyway */
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
Evas_Coord tmp;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-03-07 00:11:00 -08:00
|
|
|
tmp = xx1; xx1 = yy1; yy1 = tmp;
|
|
|
|
tmp = xx2; xx2 = yy2; yy2 = tmp;
|
2011-05-25 03:20:49 -07:00
|
|
|
tmp = w; w = h; h = tmp;
|
2012-03-07 00:11:00 -08:00
|
|
|
xx1 = (w - 1) - xx1;
|
|
|
|
xx2 = (w - 1) - xx2;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-03-07 00:11:00 -08:00
|
|
|
if (xx2 >= xx1) xx2 = xx1 - 1;
|
|
|
|
mx = (xx1 + xx2) / 2;
|
|
|
|
my = (yy1 + yy2) / 2;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (mx < 0) mx = 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
else if (mx >= w)
|
|
|
|
mx = w - 1;
|
2011-05-25 03:20:49 -07:00
|
|
|
if (my < 0) my = 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
else if (my >= h)
|
|
|
|
my = h - 1;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-03-07 00:11:00 -08:00
|
|
|
mgrad = (double)(yy1 - yy2) / (double)(xx1 - xx2);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (mx < 1) mx = 1; // quick hack to keep curl line visible
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (mgrad == 0.0) // special horizontal case
|
2012-05-15 10:37:42 -07:00
|
|
|
mgrad = 0.001; // quick dirty hack for now
|
2011-05-25 03:20:49 -07:00
|
|
|
// else
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
|
|
|
minv = 1.0 / mgrad;
|
|
|
|
// y = (m * x) + b
|
|
|
|
b = my + (minv * mx);
|
|
|
|
}
|
2011-05-25 03:20:49 -07:00
|
|
|
if ((b >= -5) && (b <= (h + 5)))
|
|
|
|
{
|
|
|
|
if (minv > 0.0) // clamp to h
|
|
|
|
{
|
|
|
|
minv = (double)(h + 5 - my) / (double)(mx);
|
|
|
|
b = my + (minv * mx);
|
|
|
|
}
|
|
|
|
else // clamp to 0
|
|
|
|
{
|
|
|
|
minv = (double)(-5 - my) / (double)(mx);
|
|
|
|
b = my + (minv * mx);
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-03-07 00:11:00 -08:00
|
|
|
perc = (double)xx2 / (double)xx1;
|
2011-05-25 03:20:49 -07:00
|
|
|
if (perc < 0.0) perc = 0.0;
|
2012-05-15 10:37:42 -07:00
|
|
|
else if (perc > 1.0)
|
|
|
|
perc = 1.0;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
minva = atan(minv) / (M_PI / 2);
|
|
|
|
if (minva < 0.0) minva = -minva;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
// A = apex of cone
|
|
|
|
if (b <= 0) A = b;
|
|
|
|
else A = h - b;
|
|
|
|
if (A < -(h * 20)) A = -h * 20;
|
|
|
|
//--//
|
|
|
|
Al = -5;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
// rho = is how much the page is turned
|
|
|
|
n = 1.0 - perc;
|
|
|
|
n = 1.0 - cos(n * M_PI / 2.0);
|
|
|
|
n = n * n;
|
|
|
|
rho = -(n * M_PI);
|
|
|
|
//--//
|
|
|
|
rhol = -(n * M_PI);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2014-02-04 21:37:46 -08:00
|
|
|
// theta == curliness (how much page curls in on itself
|
2011-05-25 03:20:49 -07:00
|
|
|
n = sin((1.0 - perc) * M_PI);
|
|
|
|
n = n * 1.2;
|
|
|
|
theta = 7.86 + n;
|
|
|
|
//--//
|
|
|
|
n = sin((1.0 - perc) * M_PI);
|
|
|
|
n = 1.0 - n;
|
|
|
|
n = n * n;
|
|
|
|
n = 1.0 - n;
|
|
|
|
thetal = 7.86 + n;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
nw = 16;
|
|
|
|
nh = 16;
|
|
|
|
gszw = w / nw;
|
|
|
|
gszh = h / nh;
|
|
|
|
if (gszw < 4) gszw = 4;
|
|
|
|
if (gszh < 4) gszh = 4;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
nw = (w + gszw - 1) / gszw;
|
|
|
|
nh = (h + gszh - 1) / gszh;
|
2012-05-15 10:37:42 -07:00
|
|
|
if ((sd->slices_w != nw) || (sd->slices_h != nh)) _state_slices_clear(sd);
|
|
|
|
sd->slices_w = nw;
|
|
|
|
sd->slices_h = nh;
|
|
|
|
if (!sd->slices)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->slices = calloc(sd->slices_w * sd->slices_h, sizeof(Slice *));
|
|
|
|
if (!sd->slices) return 0;
|
|
|
|
sd->slices2 = calloc(sd->slices_w * sd->slices_h, sizeof(Slice *));
|
|
|
|
if (!sd->slices2)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2014-01-21 18:08:47 -08:00
|
|
|
ELM_SAFE_FREE(sd->slices, free);
|
2011-05-25 03:20:49 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
num = (sd->slices_w + 1) * (sd->slices_h + 1);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
tvo = alloca(sizeof(Vertex3) * num);
|
2012-05-15 10:37:42 -07:00
|
|
|
tvol = alloca(sizeof(Vertex3) * (sd->slices_w + 1));
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
for (col = 0, gx = 0; gx <= (w + gszw - 1); gx += gszw, col++)
|
|
|
|
{
|
|
|
|
Vertex2 vil;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
vil.x = gx;
|
|
|
|
vil.y = h - ((gx * h) / (w + gszw - 1));
|
|
|
|
_deform_point(&vil, &(tvol[col]), rhol, thetal, Al);
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
n = minva * sin(perc * M_PI);
|
|
|
|
n = n * n;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
num = 0;
|
|
|
|
for (col = 0, gx = 0; gx <= (w + gszw - 1); gx += gszw, col++)
|
|
|
|
{
|
|
|
|
for (gy = 0; gy <= (h + gszh - 1); gy += gszh)
|
|
|
|
{
|
|
|
|
Vertex2 vi;
|
|
|
|
Vertex3 vo, tvo1;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (gx > w) vi.x = w;
|
|
|
|
else vi.x = gx;
|
|
|
|
if (gy > h) vi.y = h;
|
|
|
|
else vi.y = gy;
|
|
|
|
_deform_point(&vi, &vo, rho, theta, A);
|
|
|
|
tvo1 = tvol[col];
|
|
|
|
if (gy > h) tvo1.y = h;
|
|
|
|
else tvo1.y = gy;
|
|
|
|
_interp_point(&vo, &tvo1, &(tvo[num]), n);
|
|
|
|
num++;
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
jump = sd->slices_h + 1;
|
2011-05-25 03:20:49 -07:00
|
|
|
for (col = 0, gx = 0; gx < w; gx += gszw, col++)
|
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
num = sd->slices_h * col;
|
2011-05-25 03:20:49 -07:00
|
|
|
num2 = jump * col;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
gw = gszw;
|
|
|
|
if ((gx + gw) > w) gw = w - gx;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
for (row = 0, gy = 0; gy < h; gy += gszh, row++)
|
|
|
|
{
|
|
|
|
Vertex3 vo[4];
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-12-04 22:24:21 -08:00
|
|
|
memset(vo, 0, sizeof (vo));
|
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (b > 0) nn = num + sd->slices_h - row - 1;
|
2011-05-25 03:20:49 -07:00
|
|
|
else nn = num + row;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
gh = gszh;
|
|
|
|
if ((gy + gh) > h) gh = h - gy;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
vo[0] = tvo[num2 + row];
|
|
|
|
vo[1] = tvo[num2 + row + jump];
|
|
|
|
vo[2] = tvo[num2 + row + jump + 1];
|
|
|
|
vo[3] = tvo[num2 + row + 1];
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
#define SWP(a, b) \
|
|
|
|
do { \
|
|
|
|
typeof(a)vt; \
|
|
|
|
vt = (a); \
|
|
|
|
(a) = (b); \
|
|
|
|
(b) = vt; \
|
|
|
|
} while (0)
|
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
if (b > 0)
|
|
|
|
{
|
|
|
|
SWP(vo[0], vo[3]);
|
|
|
|
SWP(vo[1], vo[2]);
|
|
|
|
vo[0].y = h - vo[0].y;
|
|
|
|
vo[1].y = h - vo[1].y;
|
|
|
|
vo[2].y = h - vo[2].y;
|
|
|
|
vo[3].y = h - vo[3].y;
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
// FRONT
|
2012-05-15 10:37:42 -07:00
|
|
|
sl = sd->slices[nn];
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!sl)
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
sl = _slice_new(obj, front);
|
2015-06-15 06:38:12 -07:00
|
|
|
if (!sl) return 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->slices[nn] = sl;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_xyz(sd, sl,
|
2011-05-25 03:20:49 -07:00
|
|
|
vo[0].x, vo[0].y, vo[0].z,
|
|
|
|
vo[1].x, vo[1].y, vo[1].z,
|
|
|
|
vo[2].x, vo[2].y, vo[2].z,
|
|
|
|
vo[3].x, vo[3].y, vo[3].z);
|
|
|
|
if (b <= 0)
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_uv(sd, sl,
|
|
|
|
gx, gy, gx + gw, gy, gx + gw, gy + gh, gx, gy + gh);
|
2011-05-25 03:20:49 -07:00
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_uv(sd, sl,
|
2012-02-16 02:49:40 -08:00
|
|
|
gx, h - (gy + gh), gx + gw, h - (gy + gh), gx + gw,
|
|
|
|
h - gy, gx, h - gy);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-02-16 02:49:40 -08:00
|
|
|
// BACK
|
2012-05-15 10:37:42 -07:00
|
|
|
sl = sd->slices2[nn];
|
2011-05-25 03:20:49 -07:00
|
|
|
if (!sl)
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
sl = _slice_new(obj, back);
|
2015-06-15 06:38:12 -07:00
|
|
|
if (!sl) return 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->slices2[nn] = sl;
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_xyz(sd, sl,
|
2011-05-25 03:20:49 -07:00
|
|
|
vo[1].x, vo[1].y, vo[1].z,
|
|
|
|
vo[0].x, vo[0].y, vo[0].z,
|
|
|
|
vo[3].x, vo[3].y, vo[3].z,
|
|
|
|
vo[2].x, vo[2].y, vo[2].z);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->backflip)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
|
|
|
if (b <= 0)
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_uv(sd, sl, gx + gw, gy, gx, gy, gx, gy + gh, gx + gw,
|
2012-02-16 02:49:40 -08:00
|
|
|
gy + gh);
|
2011-05-25 03:20:49 -07:00
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_uv(sd, sl, gx + gw, h - (gy + gh), gx, h - (gy + gh),
|
2012-02-16 02:49:40 -08:00
|
|
|
gx, h - gy, gx + gw, h - gy);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (b <= 0)
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_uv(sd, sl, w - (gx + gw), gy, w - (gx), gy, w - (gx),
|
2012-02-16 02:49:40 -08:00
|
|
|
gy + gh, w - (gx + gw), gy + gh);
|
2011-05-25 03:20:49 -07:00
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_uv(sd, sl, w - (gx + gw), h - (gy + gh), w - (gx),
|
|
|
|
h - (gy + gh), w - (gx), h - gy, w - (gx + gw),
|
2012-02-16 02:49:40 -08:00
|
|
|
h - gy);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
for (num = 0; num < sd->slices_h * sd->slices_w; num++)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_apply(sd, sd->slices[num], x, y, w, h, ox, oy, ow, oh);
|
|
|
|
_slice_apply(sd, sd->slices2[num], x, y, w, h, ox, oy, ow, oh);
|
|
|
|
_slice_light(sd, sd->slices[num], ox, oy, ow, oh);
|
|
|
|
_slice_light(sd, sd->slices2[num], ox, oy, ow, oh);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
for (i = 0; i <= sd->slices_w; i++)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
num = i * sd->slices_h;
|
|
|
|
for (j = 0; j <= sd->slices_h; j++)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-03-29 19:04:16 -07:00
|
|
|
Slice *s[4] = { NULL }, *s2[4] = { NULL };
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-02-16 02:49:40 -08:00
|
|
|
if ((i > 0) && (j > 0))
|
2012-05-15 10:37:42 -07:00
|
|
|
s[0] = sd->slices[num - 1 - sd->slices_h],
|
|
|
|
s2[0] = sd->slices2[num - 1 - sd->slices_h];
|
|
|
|
if ((i < sd->slices_w) && (j > 0))
|
|
|
|
s[1] = sd->slices[num - 1],
|
|
|
|
s2[1] = sd->slices2[num - 1];
|
|
|
|
if ((i > 0) && (j < sd->slices_h))
|
|
|
|
s[2] = sd->slices[num - sd->slices_h],
|
|
|
|
s2[2] = sd->slices2[num - sd->slices_h];
|
|
|
|
if ((i < sd->slices_w) && (j < sd->slices_h))
|
|
|
|
s[3] = sd->slices[num],
|
|
|
|
s2[3] = sd->slices2[num];
|
|
|
|
switch (sd->dir)
|
2012-03-29 19:04:16 -07:00
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
case ELM_FLIP_DIRECTION_LEFT:
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s[0], 2, s[1], 3, s[2], 1, s[3], 0);
|
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s2[0], 3, s2[1], 2, s2[2], 0, s2[3], 1);
|
2012-03-29 19:04:16 -07:00
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2013-07-26 04:56:24 -07:00
|
|
|
case ELM_FLIP_DIRECTION_RIGHT:
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s[0], 3, s[1], 2, s[2], 0, s[3], 1);
|
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s2[0], 2, s2[1], 3, s2[2], 1, s2[3], 0);
|
2012-03-29 19:04:16 -07:00
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2013-07-26 04:56:24 -07:00
|
|
|
case ELM_FLIP_DIRECTION_UP:
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s[0], 3, s[1], 2, s[2], 0, s[3], 1);
|
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s2[0], 2, s2[1], 3, s2[2], 1, s2[3], 0);
|
2012-03-29 19:04:16 -07:00
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2012-03-29 19:04:16 -07:00
|
|
|
default:
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s[0], 2, s[1], 3, s[2], 1, s[3], 0);
|
|
|
|
_slice_obj_vert_color_merge
|
|
|
|
(s2[0], 3, s2[1], 2, s2[2], 0, s2[3], 1);
|
2012-03-29 19:04:16 -07:00
|
|
|
}
|
2011-05-25 03:20:49 -07:00
|
|
|
num++;
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
for (num = 0; num < sd->slices_h * sd->slices_w; num++)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
_slice_3d(sd, sd->slices[num], ox, oy, ow, oh);
|
|
|
|
_slice_3d(sd, sd->slices2[num], ox, oy, ow, oh);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_state_end(Efl_Ui_Flip_Data *sd)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
_state_slices_clear(sd);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
|
2010-09-02 02:58:52 -07:00
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_flip_show_hide(Evas_Object *obj)
|
2010-09-02 02:58:52 -07:00
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2012-02-16 00:08:16 -08:00
|
|
|
if (elm_flip_front_visible_get(obj))
|
2010-09-02 02:58:52 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->pageflip)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->front.content)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_move(sd->front.content, 4999, 4999);
|
|
|
|
evas_object_show(sd->front.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_hide(sd->front.clip);
|
|
|
|
if (sd->back.content)
|
|
|
|
evas_object_show(sd->back.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_hide(sd->back.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2010-09-02 02:58:52 -07:00
|
|
|
else
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->front.content)
|
|
|
|
evas_object_show(sd->front.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_hide(sd->front.clip);
|
|
|
|
evas_object_hide(sd->back.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2010-09-02 02:58:52 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->pageflip)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->front.content)
|
|
|
|
evas_object_show(sd->front.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_hide(sd->front.clip);
|
|
|
|
if (sd->back.content)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_move(sd->back.content, 4999, 4999);
|
|
|
|
evas_object_show(sd->back.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_hide(sd->back.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2010-09-02 02:58:52 -07:00
|
|
|
else
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-11-22 03:00:09 -08:00
|
|
|
evas_object_hide(sd->front.clip);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->back.content)
|
|
|
|
evas_object_show(sd->back.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
else
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_hide(sd->back.clip);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2010-09-02 02:58:52 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-01 21:23:41 -07:00
|
|
|
static void
|
|
|
|
_map_uv_set(Evas_Object *obj, Evas_Map *map)
|
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
|
|
|
|
// FIXME: only handles filled obj
|
2016-08-15 06:44:41 -07:00
|
|
|
if (efl_isa(obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS) &&
|
2015-10-22 10:06:01 -07:00
|
|
|
!evas_object_image_source_get(obj))
|
2012-11-01 21:23:41 -07:00
|
|
|
{
|
|
|
|
int iw, ih;
|
|
|
|
evas_object_image_size_get(obj, &iw, &ih);
|
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
|
|
|
evas_map_util_points_populate_from_geometry(map, x, y, w, h, 0);
|
|
|
|
evas_map_point_image_uv_set(map, 0, 0, 0);
|
|
|
|
evas_map_point_image_uv_set(map, 1, iw, 0);
|
|
|
|
evas_map_point_image_uv_set(map, 2, iw, ih);
|
|
|
|
evas_map_point_image_uv_set(map, 3, 0, ih);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
|
|
|
evas_map_util_points_populate_from_geometry(map, x, y, w, h, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_flip_do(Evas_Object *obj,
|
|
|
|
double t,
|
|
|
|
Elm_Flip_Mode mode,
|
|
|
|
int lin,
|
|
|
|
int rev)
|
2009-12-11 00:12:58 -08:00
|
|
|
{
|
2011-05-24 23:06:48 -07:00
|
|
|
double p, deg, pp;
|
2009-12-11 00:12:58 -08:00
|
|
|
Evas_Map *mf, *mb;
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
2010-03-09 08:46:13 -08:00
|
|
|
Evas_Coord cx, cy, px, py, foc;
|
2009-12-11 00:12:58 -08:00
|
|
|
int lx, ly, lz, lr, lg, lb, lar, lag, lab;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2009-12-11 00:12:58 -08:00
|
|
|
mf = evas_map_new(4);
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_map_smooth_set(mf, EINA_FALSE);
|
2009-12-11 00:12:58 -08:00
|
|
|
mb = evas_map_new(4);
|
2012-02-16 02:49:40 -08:00
|
|
|
evas_map_smooth_set(mb, EINA_FALSE);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->front.content)
|
2012-11-01 21:23:41 -07:00
|
|
|
_map_uv_set(sd->front.content, mf);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->back.content)
|
2012-11-01 21:23:41 -07:00
|
|
|
_map_uv_set(sd->back.content, mb);
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2010-09-25 05:41:06 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2009-12-11 00:12:58 -08:00
|
|
|
cx = x + (w / 2);
|
|
|
|
cy = y + (h / 2);
|
|
|
|
|
|
|
|
px = x + (w / 2);
|
|
|
|
py = y + (h / 2);
|
|
|
|
foc = 2048;
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2009-12-11 00:12:58 -08:00
|
|
|
lx = cx;
|
|
|
|
ly = cy;
|
|
|
|
lz = -10000;
|
|
|
|
lr = 255;
|
|
|
|
lg = 255;
|
|
|
|
lb = 255;
|
|
|
|
lar = 0;
|
|
|
|
lag = 0;
|
|
|
|
lab = 0;
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
switch (mode)
|
2009-12-11 00:12:58 -08:00
|
|
|
{
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_ROTATE_Y_CENTER_AXIS:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
if (sd->state) deg = 180.0 * p;
|
|
|
|
else deg = 180 + (180.0 * p);
|
|
|
|
if (rev) deg = -deg;
|
|
|
|
evas_map_util_3d_rotate(mf, 0.0, deg, 0.0, cx, cy, 0);
|
|
|
|
evas_map_util_3d_rotate(mb, 0.0, 180 + deg, 0.0, cx, cy, 0);
|
|
|
|
break;
|
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_ROTATE_X_CENTER_AXIS:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
if (sd->state) deg = 180.0 * p;
|
|
|
|
else deg = 180 + (180.0 * p);
|
|
|
|
if (rev) deg = -deg;
|
|
|
|
evas_map_util_3d_rotate(mf, deg, 0.0, 0.0, cx, cy, 0);
|
|
|
|
evas_map_util_3d_rotate(mb, 180.0 + deg, 0.0, 0.0, cx, cy, 0);
|
|
|
|
break;
|
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_ROTATE_XZ_CENTER_AXIS:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
if (sd->state) deg = 180.0 * p;
|
|
|
|
else deg = 180 + (180.0 * p);
|
|
|
|
if (rev) deg = -deg;
|
|
|
|
evas_map_util_3d_rotate(mf, deg, 0.0, deg, cx, cy, 0);
|
|
|
|
evas_map_util_3d_rotate(mb, 180 + deg, 0.0, 180 + deg, cx, cy, 0);
|
|
|
|
break;
|
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_ROTATE_YZ_CENTER_AXIS:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
if (sd->state) deg = 180.0 * p;
|
|
|
|
else deg = 180 + (180.0 * p);
|
|
|
|
if (rev) deg = -deg;
|
|
|
|
evas_map_util_3d_rotate(mf, 0.0, deg, deg, cx, cy, 0);
|
|
|
|
evas_map_util_3d_rotate(mb, 0.0, 180.0 + deg, 180.0 + deg, cx, cy, 0);
|
|
|
|
break;
|
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_CUBE_LEFT:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
deg = -90.0 * p;
|
|
|
|
if (sd->state)
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, 0.0, deg, 0.0, cx, cy, w / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, 0.0, deg + 90, 0.0, cx, cy, w / 2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, 0.0, deg + 90, 0.0, cx, cy, w / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, 0.0, deg, 0.0, cx, cy, w / 2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_CUBE_RIGHT:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
deg = 90.0 * p;
|
|
|
|
if (sd->state)
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, 0.0, deg, 0.0, cx, cy, w / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, 0.0, deg - 90, 0.0, cx, cy, w / 2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, 0.0, deg - 90, 0.0, cx, cy, w / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, 0.0, deg, 0.0, cx, cy, w / 2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_CUBE_UP:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
deg = -90.0 * p;
|
|
|
|
if (sd->state)
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, deg, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, deg + 90, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, deg + 90, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, deg, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
case ELM_FLIP_CUBE_DOWN:
|
2012-05-15 10:37:42 -07:00
|
|
|
p = 1.0 - t;
|
|
|
|
pp = p;
|
|
|
|
if (!lin) pp = (p * p);
|
|
|
|
p = 1.0 - pp;
|
|
|
|
deg = 90.0 * p;
|
|
|
|
if (sd->state)
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, deg, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, deg - 90, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_map_util_3d_rotate(mf, deg - 90, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
evas_map_util_3d_rotate(mb, deg, 0.0, 0.0, cx, cy, h / 2);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
case ELM_FLIP_PAGE_LEFT:
|
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
case ELM_FLIP_PAGE_RIGHT:
|
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
case ELM_FLIP_PAGE_UP:
|
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
case ELM_FLIP_PAGE_DOWN:
|
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
default:
|
2012-05-15 10:37:42 -07:00
|
|
|
break;
|
2009-12-11 00:12:58 -08:00
|
|
|
}
|
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->front.content)
|
2009-12-11 00:12:58 -08:00
|
|
|
{
|
|
|
|
evas_map_util_3d_lighting(mf, lx, ly, lz, lr, lg, lb, lar, lag, lab);
|
|
|
|
evas_map_util_3d_perspective(mf, px, py, 0, foc);
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_map_set(sd->front.content, mf);
|
2014-01-07 15:23:58 -08:00
|
|
|
evas_object_map_enable_set(sd->front.content, EINA_TRUE);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (evas_map_util_clockwise_get(mf)) evas_object_show(sd->front.clip);
|
|
|
|
else evas_object_hide(sd->front.clip);
|
2009-12-11 00:12:58 -08:00
|
|
|
}
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->back.content)
|
2009-12-11 00:12:58 -08:00
|
|
|
{
|
|
|
|
evas_map_util_3d_lighting(mb, lx, ly, lz, lr, lg, lb, lar, lag, lab);
|
|
|
|
evas_map_util_3d_perspective(mb, px, py, 0, foc);
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_map_set(sd->back.content, mb);
|
2014-01-07 15:23:58 -08:00
|
|
|
evas_object_map_enable_set(sd->back.content, EINA_TRUE);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (evas_map_util_clockwise_get(mb)) evas_object_show(sd->back.clip);
|
|
|
|
else evas_object_hide(sd->back.clip);
|
2009-12-11 00:12:58 -08:00
|
|
|
}
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2009-12-11 00:12:58 -08:00
|
|
|
evas_map_free(mf);
|
|
|
|
evas_map_free(mb);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_show_hide(Evas_Object *obj)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2011-05-25 03:20:49 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
2012-05-15 10:37:42 -07:00
|
|
|
if (!sd) return;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->front.content)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if ((sd->pageflip) && (sd->state))
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_move(sd->front.content, 4999, 4999);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (!sd->animator)
|
|
|
|
evas_object_move(sd->front.content, x, y);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_resize(sd->front.content, w, h);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->back.content)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if ((sd->pageflip) && (!sd->state))
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_move(sd->back.content, 4999, 4999);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (!sd->animator)
|
|
|
|
evas_object_move(sd->back.content, x, y);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_resize(sd->back.content, w, h);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
static void
|
|
|
|
_configure(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
Evas_Coord fsize;
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2012-05-15 10:37:42 -07:00
|
|
|
_show_hide(obj);
|
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
|
|
|
// FIXME: manual flip wont get fixed
|
|
|
|
if (sd->animator) _flip(obj);
|
|
|
|
|
|
|
|
if (sd->event[0])
|
|
|
|
{
|
|
|
|
fsize = (double)w * sd->dir_hitsize[0];
|
|
|
|
elm_coords_finger_size_adjust(0, NULL, 1, &fsize);
|
|
|
|
evas_object_move(sd->event[0], x, y);
|
|
|
|
evas_object_resize(sd->event[0], w, fsize);
|
|
|
|
}
|
|
|
|
if (sd->event[1])
|
|
|
|
{
|
|
|
|
fsize = (double)w * sd->dir_hitsize[1];
|
|
|
|
elm_coords_finger_size_adjust(0, NULL, 1, &fsize);
|
|
|
|
evas_object_move(sd->event[1], x, y + h - fsize);
|
|
|
|
evas_object_resize(sd->event[1], w, fsize);
|
|
|
|
}
|
|
|
|
if (sd->event[2])
|
|
|
|
{
|
|
|
|
fsize = (double)h * sd->dir_hitsize[2];
|
|
|
|
elm_coords_finger_size_adjust(1, &fsize, 0, NULL);
|
|
|
|
evas_object_move(sd->event[2], x, y);
|
|
|
|
evas_object_resize(sd->event[2], fsize, h);
|
|
|
|
}
|
|
|
|
if (sd->event[3])
|
|
|
|
{
|
|
|
|
fsize = (double)h * sd->dir_hitsize[3];
|
|
|
|
elm_coords_finger_size_adjust(1, &fsize, 0, NULL);
|
|
|
|
evas_object_move(sd->event[3], x + w - fsize, y);
|
|
|
|
evas_object_resize(sd->event[3], fsize, h);
|
|
|
|
}
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_flip(Evas_Object *obj)
|
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
double t;
|
2011-05-25 03:20:49 -07:00
|
|
|
Evas_Coord w, h;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
t = ecore_loop_time_get() - sd->start;
|
|
|
|
|
|
|
|
if (!sd->animator) return ECORE_CALLBACK_CANCEL;
|
|
|
|
|
|
|
|
t = t / sd->len;
|
2011-05-24 23:06:48 -07:00
|
|
|
if (t > 1.0) t = 1.0;
|
2011-05-25 03:20:49 -07:00
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
|
2012-08-02 01:42:06 -07:00
|
|
|
if (!sd->manual)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2012-08-02 01:42:06 -07:00
|
|
|
if (sd->mode == ELM_FLIP_PAGE_LEFT)
|
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
sd->dir = ELM_FLIP_DIRECTION_LEFT;
|
2012-08-02 01:42:06 -07:00
|
|
|
sd->started = EINA_TRUE;
|
|
|
|
sd->pageflip = EINA_TRUE;
|
|
|
|
sd->down_x = w - 1;
|
|
|
|
sd->down_y = h / 2;
|
|
|
|
sd->x = (1.0 - t) * sd->down_x;
|
|
|
|
sd->y = sd->down_y;
|
|
|
|
_flip_show_hide(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
_state_update(obj);
|
2012-08-02 01:42:06 -07:00
|
|
|
}
|
|
|
|
else if (sd->mode == ELM_FLIP_PAGE_RIGHT)
|
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
sd->dir = ELM_FLIP_DIRECTION_RIGHT;
|
2012-08-02 01:42:06 -07:00
|
|
|
sd->started = EINA_TRUE;
|
|
|
|
sd->pageflip = EINA_TRUE;
|
|
|
|
sd->down_x = 0;
|
|
|
|
sd->down_y = h / 2;
|
|
|
|
sd->x = (t) * w;
|
|
|
|
sd->y = sd->down_y;
|
|
|
|
_flip_show_hide(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
_state_update(obj);
|
2012-08-02 01:42:06 -07:00
|
|
|
}
|
|
|
|
else if (sd->mode == ELM_FLIP_PAGE_UP)
|
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
sd->dir = ELM_FLIP_DIRECTION_UP;
|
2012-08-02 01:42:06 -07:00
|
|
|
sd->started = EINA_TRUE;
|
|
|
|
sd->pageflip = EINA_TRUE;
|
|
|
|
sd->down_x = w / 2;
|
|
|
|
sd->down_y = h - 1;
|
|
|
|
sd->x = sd->down_x;
|
|
|
|
sd->y = (1.0 - t) * sd->down_y;
|
|
|
|
_flip_show_hide(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
_state_update(obj);
|
2012-08-02 01:42:06 -07:00
|
|
|
}
|
|
|
|
else if (sd->mode == ELM_FLIP_PAGE_DOWN)
|
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
sd->dir = ELM_FLIP_DIRECTION_DOWN;
|
2012-08-02 01:42:06 -07:00
|
|
|
sd->started = EINA_TRUE;
|
|
|
|
sd->pageflip = EINA_TRUE;
|
|
|
|
sd->down_x = w / 2;
|
|
|
|
sd->down_y = 0;
|
|
|
|
sd->x = sd->down_x;
|
|
|
|
sd->y = (t) * h;
|
|
|
|
_flip_show_hide(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
_state_update(obj);
|
2012-08-02 01:42:06 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
_flip_do(obj, t, sd->mode, 0, 0);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2013-09-30 03:21:31 -07:00
|
|
|
|
2009-12-11 00:12:58 -08:00
|
|
|
if (t >= 1.0)
|
|
|
|
{
|
2012-08-02 01:42:06 -07:00
|
|
|
#if 0 // this breaks manual flipping. :/
|
2012-07-24 14:39:12 -07:00
|
|
|
if (sd->state == sd->next_state)
|
|
|
|
{
|
|
|
|
/* it was flipped while flipping, do it again */
|
|
|
|
sd->start = ecore_loop_time_get();
|
|
|
|
sd->state = !sd->next_state;
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
2012-08-02 01:42:06 -07:00
|
|
|
#endif
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->pageflip = EINA_FALSE;
|
|
|
|
_state_end(sd);
|
2014-01-07 15:23:58 -08:00
|
|
|
evas_object_map_enable_set(sd->front.content, EINA_FALSE);
|
|
|
|
evas_object_map_enable_set(sd->back.content, EINA_FALSE);
|
2010-09-03 01:27:05 -07:00
|
|
|
// FIXME: hack around evas rendering bug (only fix makes evas bitch-slow
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_resize(sd->front.content, 0, 0);
|
|
|
|
evas_object_resize(sd->back.content, 0, 0);
|
2010-09-03 01:27:05 -07:00
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(obj));
|
|
|
|
// FIXME: end hack
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->animator = NULL;
|
2012-08-02 01:42:06 -07:00
|
|
|
if (((sd->manual) && (sd->finish)) || (!sd->manual))
|
|
|
|
sd->state = sd->next_state;
|
2010-01-26 00:17:26 -08:00
|
|
|
_configure(obj);
|
2012-05-15 10:37:42 -07:00
|
|
|
_flip_show_hide(obj);
|
2016-08-22 15:40:39 -07:00
|
|
|
efl_event_callback_legacy_call(obj, EFL_UI_FLIP_EVENT_ANIMATE_DONE, NULL);
|
2016-06-06 16:50:26 -07:00
|
|
|
|
|
|
|
// update the new front and back object.
|
|
|
|
_update_front_back(obj, sd);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2009-12-11 00:12:58 -08:00
|
|
|
}
|
2011-05-25 03:20:49 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
2009-12-11 00:12:58 -08:00
|
|
|
}
|
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
/* we have to have move/resize info up-to-date on those events. it
|
|
|
|
* happens that smarts callbacks on them happen before we have the new
|
|
|
|
* values, so using event callbacks instead */
|
2009-12-11 00:12:58 -08:00
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_on_move(void *data EINA_UNUSED,
|
|
|
|
Evas *e EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *event_info EINA_UNUSED)
|
2009-12-11 00:12:58 -08:00
|
|
|
{
|
|
|
|
_configure(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_on_resize(void *data EINA_UNUSED,
|
|
|
|
Evas *e EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *event_info EINA_UNUSED)
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
{
|
2009-12-11 00:12:58 -08:00
|
|
|
_configure(obj);
|
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2009-12-11 00:12:58 -08:00
|
|
|
_animate(void *data)
|
|
|
|
{
|
|
|
|
return _flip(data);
|
|
|
|
}
|
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
static double
|
2012-11-25 22:32:53 -08:00
|
|
|
_pos_get(Evas_Object *obj,
|
2016-06-06 16:50:26 -07:00
|
|
|
Efl_Ui_Flip_Data *sd,
|
2012-05-15 10:37:42 -07:00
|
|
|
int *rev,
|
|
|
|
Elm_Flip_Mode *m)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
double t = 1.0;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
2012-05-15 10:37:42 -07:00
|
|
|
switch (sd->intmode)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
case EFL_UI_FLIP_INTERACTION_ROTATE:
|
|
|
|
case EFL_UI_FLIP_INTERACTION_CUBE:
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
if (sd->dir == ELM_FLIP_DIRECTION_LEFT)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
|
|
|
if (sd->down_x > 0)
|
|
|
|
t = 1.0 - ((double)sd->x / (double)sd->down_x);
|
|
|
|
*rev = 1;
|
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_RIGHT)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
|
|
|
if (sd->down_x < w)
|
|
|
|
t = 1.0 - ((double)(w - sd->x) / (double)(w - sd->down_x));
|
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_UP)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
|
|
|
if (sd->down_y > 0)
|
|
|
|
t = 1.0 - ((double)sd->y / (double)sd->down_y);
|
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_DOWN)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
|
|
|
if (sd->down_y < h)
|
|
|
|
t = 1.0 - ((double)(h - sd->y) / (double)(h - sd->down_y));
|
|
|
|
*rev = 1;
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (t < 0.0) t = 0.0;
|
|
|
|
else if (t > 1.0)
|
|
|
|
t = 1.0;
|
|
|
|
|
2013-07-26 04:56:24 -07:00
|
|
|
if ((sd->dir == ELM_FLIP_DIRECTION_LEFT) ||
|
|
|
|
(sd->dir == ELM_FLIP_DIRECTION_RIGHT))
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
if (sd->intmode == EFL_UI_FLIP_INTERACTION_ROTATE)
|
2012-05-15 10:37:42 -07:00
|
|
|
*m = ELM_FLIP_ROTATE_Y_CENTER_AXIS;
|
2016-06-06 16:50:26 -07:00
|
|
|
else if (sd->intmode == EFL_UI_FLIP_INTERACTION_CUBE)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
|
|
|
if (*rev)
|
|
|
|
*m = ELM_FLIP_CUBE_LEFT;
|
|
|
|
else
|
|
|
|
*m = ELM_FLIP_CUBE_RIGHT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
if (sd->intmode == EFL_UI_FLIP_INTERACTION_ROTATE)
|
2012-05-15 10:37:42 -07:00
|
|
|
*m = ELM_FLIP_ROTATE_X_CENTER_AXIS;
|
2016-06-06 16:50:26 -07:00
|
|
|
else if (sd->intmode == EFL_UI_FLIP_INTERACTION_CUBE)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
|
|
|
if (*rev)
|
|
|
|
*m = ELM_FLIP_CUBE_UP;
|
|
|
|
else
|
|
|
|
*m = ELM_FLIP_CUBE_DOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2012-05-15 10:37:42 -07:00
|
|
|
_event_anim(void *data,
|
|
|
|
double pos)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
Efl_Ui_Flip_Data *sd = data;
|
2011-05-24 23:06:48 -07:00
|
|
|
double p;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
p = ecore_animator_pos_map(pos, ECORE_POS_MAP_ACCELERATE, 0.0, 0.0);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->finish)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
if (sd->dir == ELM_FLIP_DIRECTION_LEFT)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->x = sd->ox * (1.0 - p);
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_RIGHT)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->x = sd->ox + ((sd->w - sd->ox) * p);
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_UP)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->y = sd->oy * (1.0 - p);
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_DOWN)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->y = sd->oy + ((sd->h - sd->oy) * p);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-07-26 04:56:24 -07:00
|
|
|
if (sd->dir == ELM_FLIP_DIRECTION_LEFT)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->x = sd->ox + ((sd->w - sd->ox) * p);
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_RIGHT)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->x = sd->ox * (1.0 - p);
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_UP)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->y = sd->oy + ((sd->h - sd->oy) * p);
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_DOWN)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->y = sd->oy * (1.0 - p);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
switch (sd->intmode)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
case EFL_UI_FLIP_INTERACTION_NONE:
|
2011-05-24 23:06:48 -07:00
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
case EFL_UI_FLIP_INTERACTION_ROTATE:
|
|
|
|
case EFL_UI_FLIP_INTERACTION_CUBE:
|
2013-11-14 01:30:14 -08:00
|
|
|
{
|
|
|
|
Elm_Flip_Mode m = ELM_FLIP_ROTATE_X_CENTER_AXIS;
|
|
|
|
int rev = 0;
|
|
|
|
p = _pos_get(sd->obj, sd, &rev, &m);
|
|
|
|
_flip_do(sd->obj, p, m, 1, rev);
|
|
|
|
}
|
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
case EFL_UI_FLIP_INTERACTION_PAGE:
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->pageflip = EINA_TRUE;
|
2012-11-25 22:32:53 -08:00
|
|
|
_configure(sd->obj);
|
|
|
|
_state_update(sd->obj);
|
2011-05-24 23:06:48 -07:00
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (pos < 1.0) return ECORE_CALLBACK_RENEW;
|
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->pageflip = EINA_FALSE;
|
|
|
|
_state_end(sd);
|
2014-01-07 15:23:58 -08:00
|
|
|
evas_object_map_enable_set(sd->front.content, EINA_FALSE);
|
|
|
|
evas_object_map_enable_set(sd->back.content, EINA_FALSE);
|
2011-05-24 23:06:48 -07:00
|
|
|
// FIXME: hack around evas rendering bug (only fix makes evas bitch-slow
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_resize(sd->front.content, 0, 0);
|
|
|
|
evas_object_resize(sd->back.content, 0, 0);
|
|
|
|
evas_smart_objects_calculate
|
2012-11-25 22:32:53 -08:00
|
|
|
(evas_object_evas_get(sd->obj));
|
2011-05-24 23:06:48 -07:00
|
|
|
// FIXME: end hack
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->animator = NULL;
|
2012-08-02 01:42:06 -07:00
|
|
|
if (sd->finish) sd->state = sd->next_state;
|
2012-11-25 22:32:53 -08:00
|
|
|
_flip_show_hide(sd->obj);
|
|
|
|
_configure(sd->obj);
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->animator = NULL;
|
2016-08-22 15:40:39 -07:00
|
|
|
efl_event_callback_legacy_call
|
2016-06-06 16:50:26 -07:00
|
|
|
(sd->obj, EFL_UI_FLIP_EVENT_ANIMATE_DONE, NULL);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_update_job(void *data)
|
|
|
|
{
|
|
|
|
Elm_Flip_Mode m = ELM_FLIP_ROTATE_X_CENTER_AXIS;
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = data;
|
2016-08-15 06:44:41 -07:00
|
|
|
Efl_Ui_Flip_Data *sd = efl_data_scope_get(obj, MY_CLASS);
|
2011-05-24 23:06:48 -07:00
|
|
|
int rev = 0;
|
2012-05-15 10:37:42 -07:00
|
|
|
double p;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->job = NULL;
|
|
|
|
switch (sd->intmode)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
case EFL_UI_FLIP_INTERACTION_ROTATE:
|
|
|
|
case EFL_UI_FLIP_INTERACTION_CUBE:
|
2012-11-25 22:32:53 -08:00
|
|
|
p = _pos_get(obj, sd, &rev, &m);
|
|
|
|
_flip_do(obj, p, m, 1, rev);
|
2011-05-24 23:06:48 -07:00
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
case EFL_UI_FLIP_INTERACTION_PAGE:
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->pageflip = EINA_TRUE;
|
2012-11-25 22:32:53 -08:00
|
|
|
_configure(obj);
|
|
|
|
_state_update(obj);
|
2011-05-24 23:06:48 -07:00
|
|
|
break;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_down_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
void *event_info)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object *fl = data;
|
2011-05-24 23:06:48 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(fl, sd);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
if (ev->button != 1) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2013-05-29 04:52:16 -07:00
|
|
|
ELM_SAFE_FREE(sd->animator, ecore_animator_del);
|
2014-03-22 01:54:49 -07:00
|
|
|
sd->mouse_down = EINA_TRUE;
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->started = EINA_FALSE;
|
2011-05-24 23:06:48 -07:00
|
|
|
evas_object_geometry_get(data, &x, &y, &w, &h);
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->x = ev->canvas.x - x;
|
|
|
|
sd->y = ev->canvas.y - y;
|
|
|
|
sd->w = w;
|
|
|
|
sd->h = h;
|
|
|
|
sd->down_x = sd->x;
|
|
|
|
sd->down_y = sd->y;
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_up_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
void *event_info)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object *fl = data;
|
2011-05-24 23:06:48 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
double tm = 0.5;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(fl, sd);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
if (ev->button != 1) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2014-03-22 01:54:49 -07:00
|
|
|
sd->mouse_down = EINA_FALSE;
|
2013-07-26 05:12:27 -07:00
|
|
|
if (!sd->started) return;
|
2011-05-24 23:06:48 -07:00
|
|
|
evas_object_geometry_get(data, &x, &y, &w, &h);
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->x = ev->canvas.x - x;
|
|
|
|
sd->y = ev->canvas.y - y;
|
|
|
|
sd->w = w;
|
|
|
|
sd->h = h;
|
|
|
|
sd->ox = sd->x;
|
|
|
|
sd->oy = sd->y;
|
2013-05-29 04:52:16 -07:00
|
|
|
ELM_SAFE_FREE(sd->job, ecore_job_del);
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->finish = EINA_FALSE;
|
2013-07-26 04:56:24 -07:00
|
|
|
if (sd->dir == ELM_FLIP_DIRECTION_LEFT)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
tm = (double)sd->x / (double)sd->w;
|
|
|
|
if (sd->x < (sd->w / 2)) sd->finish = EINA_TRUE;
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_RIGHT)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->x > (sd->w / 2)) sd->finish = EINA_TRUE;
|
|
|
|
tm = 1.0 - ((double)sd->x / (double)sd->w);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_UP)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->y < (sd->h / 2)) sd->finish = EINA_TRUE;
|
|
|
|
tm = (double)sd->y / (double)sd->h;
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
2013-07-26 04:56:24 -07:00
|
|
|
else if (sd->dir == ELM_FLIP_DIRECTION_DOWN)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->y > (sd->h / 2)) sd->finish = EINA_TRUE;
|
|
|
|
tm = 1.0 - ((double)sd->y / (double)sd->h);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
if (tm < 0.01) tm = 0.01;
|
2012-08-02 01:42:06 -07:00
|
|
|
else if (tm > 0.99) tm = 0.99;
|
2012-05-15 10:37:42 -07:00
|
|
|
if (!sd->finish) tm = 1.0 - tm;
|
2012-08-02 01:42:06 -07:00
|
|
|
else sd->next_state = !sd->state;
|
2011-05-24 23:06:48 -07:00
|
|
|
tm *= 1.0; // FIXME: config for anim time
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_animator_del(sd->animator);
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->animator = ecore_animator_timeline_add(tm, _event_anim, sd);
|
2012-08-02 01:42:06 -07:00
|
|
|
sd->len = tm;
|
|
|
|
sd->start = ecore_loop_time_get();
|
|
|
|
sd->manual = EINA_TRUE;
|
2012-05-15 10:37:42 -07:00
|
|
|
_event_anim(sd, 0.0);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-15 10:37:42 -07:00
|
|
|
_move_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-05-15 10:37:42 -07:00
|
|
|
void *event_info)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Move *ev = event_info;
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object *fl = data;
|
2011-05-24 23:06:48 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(fl, sd);
|
2014-03-22 01:54:49 -07:00
|
|
|
if (!sd->mouse_down) return;
|
2012-05-15 10:37:42 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2011-05-24 23:06:48 -07:00
|
|
|
evas_object_geometry_get(data, &x, &y, &w, &h);
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->x = ev->cur.canvas.x - x;
|
|
|
|
sd->y = ev->cur.canvas.y - y;
|
|
|
|
sd->w = w;
|
|
|
|
sd->h = h;
|
|
|
|
if (!sd->started)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
|
|
|
Evas_Coord dx, dy;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
dx = sd->x - sd->down_x;
|
|
|
|
dy = sd->y - sd->down_y;
|
2012-02-16 02:49:40 -08:00
|
|
|
if (((dx * dx) + (dy * dy)) >
|
|
|
|
(_elm_config->finger_size * _elm_config->finger_size / 4))
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if ((sd->x > (w / 2)) &&
|
|
|
|
(dx < 0) && (abs(dx) > abs(dy)))
|
2013-07-26 05:12:27 -07:00
|
|
|
{
|
|
|
|
sd->dir = ELM_FLIP_DIRECTION_LEFT;
|
|
|
|
if (!sd->dir_enabled[ELM_FLIP_DIRECTION_LEFT]) return;
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
else if ((sd->x < (w / 2)) && (dx >= 0) &&
|
2012-02-16 02:49:40 -08:00
|
|
|
(abs(dx) > abs(dy)))
|
2013-07-26 05:12:27 -07:00
|
|
|
{
|
|
|
|
sd->dir = ELM_FLIP_DIRECTION_RIGHT;
|
|
|
|
if (!sd->dir_enabled[ELM_FLIP_DIRECTION_RIGHT]) return;
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
else if ((sd->y > (h / 2)) && (dy < 0) && (abs(dy) >= abs(dx)))
|
2013-07-26 05:12:27 -07:00
|
|
|
{
|
|
|
|
sd->dir = ELM_FLIP_DIRECTION_UP;
|
|
|
|
if (!sd->dir_enabled[ELM_FLIP_DIRECTION_UP]) return;
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
else if ((sd->y < (h / 2)) && (dy >= 0) && (abs(dy) >= abs(dx)))
|
2013-07-26 05:12:27 -07:00
|
|
|
{
|
|
|
|
sd->dir = ELM_FLIP_DIRECTION_DOWN;
|
|
|
|
if (!sd->dir_enabled[ELM_FLIP_DIRECTION_DOWN]) return;
|
|
|
|
}
|
2013-12-10 18:37:04 -08:00
|
|
|
else return;
|
2013-07-26 05:12:27 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->started = EINA_TRUE;
|
2016-06-06 16:50:26 -07:00
|
|
|
if (sd->intmode == EFL_UI_FLIP_INTERACTION_PAGE)
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->pageflip = EINA_TRUE;
|
|
|
|
_flip_show_hide(data);
|
2011-05-24 23:06:48 -07:00
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(data));
|
|
|
|
_flip(data);
|
2012-05-15 10:37:42 -07:00
|
|
|
// FIXME: hack around evas rendering bug (only fix makes
|
|
|
|
// evas bitch-slow)
|
|
|
|
evas_object_map_enable_set(sd->front.content, EINA_FALSE);
|
|
|
|
evas_object_map_enable_set(sd->back.content, EINA_FALSE);
|
2011-06-01 21:24:58 -07:00
|
|
|
// FIXME: XXX why does this bork interactive flip??
|
2012-05-15 10:37:42 -07:00
|
|
|
// evas_object_resize(sd->front.content, 0, 0);
|
|
|
|
// evas_object_resize(sd->back.content, 0, 0);
|
2011-05-24 23:06:48 -07:00
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(data));
|
2012-06-07 19:16:19 -07:00
|
|
|
_configure(fl);
|
2011-05-24 23:06:48 -07:00
|
|
|
// FIXME: end hack
|
2016-08-22 15:40:39 -07:00
|
|
|
efl_event_callback_legacy_call(fl, EFL_UI_FLIP_EVENT_ANIMATE_BEGIN, NULL);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
else return;
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-26 02:02:00 -07:00
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->job);
|
2012-11-25 22:32:53 -08:00
|
|
|
sd->job = ecore_job_add(_update_job, fl);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_flip_content_set(Evas_Object *obj,
|
|
|
|
Evas_Object *content,
|
|
|
|
Eina_Bool front)
|
2012-02-15 23:31:55 -08:00
|
|
|
{
|
|
|
|
int i;
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object **cont;
|
2012-02-15 23:31:55 -08:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2012-02-15 23:31:55 -08:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
cont = front ? &(sd->front.content) : &(sd->back.content);
|
2012-02-15 23:31:55 -08:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (*cont == content) return EINA_TRUE;
|
|
|
|
|
2014-01-21 17:38:55 -08:00
|
|
|
evas_object_del(*cont);
|
2012-05-15 10:37:42 -07:00
|
|
|
*cont = content;
|
2012-02-15 23:31:55 -08:00
|
|
|
|
|
|
|
if (content)
|
|
|
|
{
|
|
|
|
elm_widget_sub_object_add(obj, content);
|
2012-05-15 10:37:42 -07:00
|
|
|
//evas_object_smart_member_add(content, obj);
|
|
|
|
evas_object_clip_set
|
|
|
|
(content, front ? sd->front.clip : sd->back.clip);
|
2012-02-15 23:31:55 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// force calc to contents are the right size before transition
|
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(obj));
|
2012-05-15 10:37:42 -07:00
|
|
|
//evas_object_smart_calculate(obj);
|
|
|
|
_flip_show_hide(obj);
|
2012-02-15 23:31:55 -08:00
|
|
|
_configure(obj);
|
2012-05-15 10:37:42 -07:00
|
|
|
_sizing_eval(obj);
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
if (sd->intmode != EFL_UI_FLIP_INTERACTION_NONE)
|
2012-02-15 23:31:55 -08:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
evas_object_raise(sd->event[i]);
|
2012-02-15 23:31:55 -08:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
2012-02-15 23:31:55 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Object *
|
2012-05-15 10:37:42 -07:00
|
|
|
_flip_content_unset(Evas_Object *obj,
|
|
|
|
Eina_Bool front)
|
2012-02-15 23:31:55 -08:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
Evas_Object *content;
|
|
|
|
Evas_Object **cont;
|
2012-02-15 23:31:55 -08:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
2012-02-15 23:31:55 -08:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
cont = front ? &(sd->front.content) : &(sd->back.content);
|
2012-02-15 23:31:55 -08:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (!*cont) return NULL;
|
|
|
|
|
|
|
|
content = *cont;
|
2016-05-29 17:47:39 -07:00
|
|
|
_elm_widget_sub_object_redirect_to_top(obj, content);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2012-02-15 23:31:55 -08:00
|
|
|
return content;
|
|
|
|
}
|
|
|
|
|
2016-05-24 04:40:18 -07:00
|
|
|
static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_content_set(Eo *obj, Efl_Ui_Flip_Data *_pd EINA_UNUSED, const char *part, Evas_Object *content)
|
2012-02-15 23:31:55 -08:00
|
|
|
{
|
|
|
|
if (!part || !strcmp(part, "front"))
|
2014-03-23 02:14:48 -07:00
|
|
|
return _flip_content_set(obj, content, EINA_TRUE);
|
2012-02-15 23:31:55 -08:00
|
|
|
else if (!strcmp(part, "back"))
|
2014-03-23 02:14:48 -07:00
|
|
|
return _flip_content_set(obj, content, EINA_FALSE);
|
|
|
|
return EINA_FALSE;
|
2012-02-15 23:31:55 -08:00
|
|
|
}
|
|
|
|
|
2016-05-24 04:40:18 -07:00
|
|
|
static Evas_Object*
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_content_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, const char *part)
|
2012-02-15 23:31:55 -08:00
|
|
|
{
|
|
|
|
if (!part || !strcmp(part, "front"))
|
2014-03-23 02:14:48 -07:00
|
|
|
return sd->front.content;
|
2012-02-15 23:31:55 -08:00
|
|
|
else if (!strcmp(part, "back"))
|
2014-03-23 02:14:48 -07:00
|
|
|
return sd->back.content;
|
|
|
|
return NULL;
|
2012-02-15 23:31:55 -08:00
|
|
|
}
|
|
|
|
|
2016-05-24 04:40:18 -07:00
|
|
|
static Evas_Object*
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_content_unset(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *_pd EINA_UNUSED, const char *part)
|
2012-02-15 23:31:55 -08:00
|
|
|
{
|
|
|
|
if (!part || !strcmp(part, "front"))
|
2014-03-23 02:14:48 -07:00
|
|
|
return _flip_content_unset(obj, EINA_TRUE);
|
2012-02-15 23:31:55 -08:00
|
|
|
else if (!strcmp(part, "back"))
|
2014-03-23 02:14:48 -07:00
|
|
|
return _flip_content_unset(obj, EINA_FALSE);
|
|
|
|
return NULL;
|
2012-02-15 23:31:55 -08:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2016-06-17 01:26:08 -07:00
|
|
|
_efl_ui_flip_efl_canvas_group_group_add(Eo *obj, Efl_Ui_Flip_Data *priv)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_canvas_group_add(efl_super(obj, MY_CLASS));
|
2013-09-24 21:33:39 -07:00
|
|
|
elm_widget_sub_object_parent_add(obj);
|
2013-08-26 08:29:45 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
priv->clip = evas_object_rectangle_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_static_clip_set(priv->clip, EINA_TRUE);
|
|
|
|
evas_object_move(priv->clip, -49999, -49999);
|
|
|
|
evas_object_resize(priv->clip, 99999, 99999);
|
|
|
|
evas_object_smart_member_add(priv->clip, obj);
|
|
|
|
|
|
|
|
priv->front.clip = evas_object_rectangle_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_static_clip_set(priv->front.clip, EINA_TRUE);
|
|
|
|
evas_object_data_set(priv->front.clip, "_elm_leaveme", obj);
|
|
|
|
evas_object_move(priv->front.clip, -49999, -49999);
|
|
|
|
evas_object_resize(priv->front.clip, 99999, 99999);
|
|
|
|
evas_object_smart_member_add(priv->front.clip, obj);
|
|
|
|
evas_object_clip_set(priv->front.clip, priv->clip);
|
|
|
|
|
|
|
|
priv->back.clip = evas_object_rectangle_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_static_clip_set(priv->back.clip, EINA_TRUE);
|
|
|
|
evas_object_data_set(priv->back.clip, "_elm_leaveme", obj);
|
|
|
|
evas_object_move(priv->back.clip, -49999, -49999);
|
|
|
|
evas_object_resize(priv->back.clip, 99999, 99999);
|
|
|
|
evas_object_smart_member_add(priv->back.clip, obj);
|
|
|
|
evas_object_clip_set(priv->back.clip, priv->clip);
|
|
|
|
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints_cb, obj);
|
|
|
|
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _on_resize, NULL);
|
2012-05-16 12:28:07 -07:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE, _on_move, NULL);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
priv->state = EINA_TRUE;
|
2012-07-24 14:39:12 -07:00
|
|
|
priv->next_state = EINA_TRUE;
|
2016-06-06 16:50:26 -07:00
|
|
|
priv->intmode = EFL_UI_FLIP_INTERACTION_NONE;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
elm_widget_can_focus_set(obj, EINA_FALSE);
|
|
|
|
|
|
|
|
_sizing_eval(obj);
|
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2016-06-17 01:26:08 -07:00
|
|
|
_efl_ui_flip_efl_canvas_group_group_del(Eo *obj, Efl_Ui_Flip_Data *sd)
|
2012-05-15 10:37:42 -07:00
|
|
|
{
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_animator_del(sd->animator);
|
2012-05-15 10:37:42 -07:00
|
|
|
_state_slices_clear(sd);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_canvas_group_del(efl_super(obj, MY_CLASS));
|
2012-05-15 10:37:42 -07:00
|
|
|
}
|
|
|
|
|
2009-12-01 23:22:35 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_flip_add(Evas_Object *parent)
|
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object *obj = efl_add(MY_CLASS, parent);
|
2012-11-25 22:32:53 -08:00
|
|
|
return obj;
|
|
|
|
}
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
|
2015-05-19 05:34:07 -07:00
|
|
|
EOLIAN static Eo *
|
2016-08-10 07:23:04 -07:00
|
|
|
_efl_ui_flip_efl_object_constructor(Eo *obj, Efl_Ui_Flip_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_constructor(efl_super(obj, MY_CLASS));
|
2012-11-25 22:32:53 -08:00
|
|
|
sd->obj = obj;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2016-06-20 21:26:15 -07:00
|
|
|
efl_canvas_object_type_set(obj, MY_CLASS_NAME_LEGACY);
|
2016-06-16 22:12:02 -07:00
|
|
|
evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
|
2016-03-02 04:10:48 -08:00
|
|
|
elm_interface_atspi_accessible_role_set(obj, ELM_ATSPI_ROLE_PAGE_TAB_LIST);
|
2015-05-19 05:34:07 -07:00
|
|
|
|
|
|
|
return obj;
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_front_visible_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-23 02:14:48 -07:00
|
|
|
return sd->state;
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-05-15 10:37:42 -07:00
|
|
|
elm_flip_perspective_set(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Coord foc EINA_UNUSED,
|
|
|
|
Evas_Coord x EINA_UNUSED,
|
|
|
|
Evas_Coord y EINA_UNUSED)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
ELM_FLIP_CHECK(obj);
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
// FIXME: add ambient and lighting control
|
|
|
|
|
2012-07-24 14:57:11 -07:00
|
|
|
static void
|
2014-03-23 02:14:48 -07:00
|
|
|
_internal_elm_flip_go_to(Evas_Object *obj,
|
2016-06-06 16:50:26 -07:00
|
|
|
Efl_Ui_Flip_Data *sd,
|
2012-07-24 14:57:11 -07:00
|
|
|
Eina_Bool front,
|
|
|
|
Elm_Flip_Mode mode)
|
2009-12-01 23:22:35 -08:00
|
|
|
{
|
2012-05-15 10:37:42 -07:00
|
|
|
if (!sd->animator) sd->animator = ecore_animator_add(_animate, obj);
|
|
|
|
_flip_show_hide(obj);
|
|
|
|
|
|
|
|
sd->mode = mode;
|
|
|
|
sd->start = ecore_loop_time_get();
|
2012-07-24 14:57:11 -07:00
|
|
|
sd->next_state = front;
|
2012-05-15 10:37:42 -07:00
|
|
|
sd->len = 0.5; // FIXME: make config val
|
2012-08-02 01:42:06 -07:00
|
|
|
sd->manual = EINA_FALSE;
|
2012-05-15 10:37:42 -07:00
|
|
|
if ((sd->mode == ELM_FLIP_PAGE_LEFT) ||
|
|
|
|
(sd->mode == ELM_FLIP_PAGE_RIGHT) ||
|
|
|
|
(sd->mode == ELM_FLIP_PAGE_UP) ||
|
|
|
|
(sd->mode == ELM_FLIP_PAGE_DOWN))
|
|
|
|
sd->pageflip = EINA_TRUE;
|
2010-09-25 05:41:06 -07:00
|
|
|
// force calc to contents are the right size before transition
|
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(obj));
|
2010-09-02 02:58:52 -07:00
|
|
|
_flip(obj);
|
2011-05-24 00:49:50 -07:00
|
|
|
// FIXME: hack around evas rendering bug (only fix makes evas bitch-slow)
|
2014-01-07 15:23:58 -08:00
|
|
|
evas_object_map_enable_set(sd->front.content, EINA_FALSE);
|
|
|
|
evas_object_map_enable_set(sd->back.content, EINA_FALSE);
|
2012-05-15 10:37:42 -07:00
|
|
|
evas_object_resize(sd->front.content, 0, 0);
|
|
|
|
evas_object_resize(sd->back.content, 0, 0);
|
2010-09-25 07:57:34 -07:00
|
|
|
evas_smart_objects_calculate(evas_object_evas_get(obj));
|
|
|
|
_configure(obj);
|
|
|
|
// FIXME: end hack
|
2016-08-22 15:40:39 -07:00
|
|
|
efl_event_callback_legacy_call(obj, EFL_UI_FLIP_EVENT_ANIMATE_BEGIN, NULL);
|
2013-09-15 08:14:50 -07:00
|
|
|
|
|
|
|
// set focus to the content object when flip go to is called
|
|
|
|
if (elm_object_focus_get(obj))
|
|
|
|
{
|
|
|
|
if (front) elm_object_focus_set(sd->front.content, EINA_TRUE);
|
|
|
|
else elm_object_focus_set(sd->back.content, EINA_TRUE);
|
|
|
|
}
|
2009-12-01 23:22:35 -08:00
|
|
|
}
|
2011-05-24 23:06:48 -07:00
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_go_to(Eo *obj, Efl_Ui_Flip_Data *sd, Eina_Bool front, Elm_Flip_Mode mode)
|
2012-07-24 14:57:11 -07:00
|
|
|
{
|
|
|
|
if (sd->next_state == front) return;
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
_internal_elm_flip_go_to(obj, sd, front, mode);
|
2012-07-24 14:57:11 -07:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_go(Eo *obj, Efl_Ui_Flip_Data *sd, Elm_Flip_Mode mode)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2014-03-23 02:14:48 -07:00
|
|
|
_internal_elm_flip_go_to(obj, sd, !sd->state, mode);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2013-12-10 18:37:04 -08:00
|
|
|
static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_event_rect_create(Eo *obj, Efl_Ui_Flip_Data *sd, int i)
|
2013-12-10 18:37:04 -08:00
|
|
|
{
|
|
|
|
Evas_Object *clip;
|
|
|
|
Evas *e;
|
|
|
|
|
|
|
|
if (sd->event[i]) return;
|
|
|
|
|
|
|
|
e = evas_object_evas_get(obj);
|
|
|
|
sd->event[i] = evas_object_rectangle_add(e);
|
|
|
|
|
|
|
|
clip = evas_object_clip_get(obj);
|
|
|
|
evas_object_data_set(sd->event[i], "_elm_leaveme", obj);
|
|
|
|
evas_object_clip_set(sd->event[i], clip);
|
|
|
|
evas_object_color_set(sd->event[i], 0, 0, 0, 0);
|
|
|
|
evas_object_show(sd->event[i]);
|
|
|
|
evas_object_smart_member_add(sd->event[i], obj);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(sd->event[i], EVAS_CALLBACK_MOUSE_DOWN, _down_cb, obj);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(sd->event[i], EVAS_CALLBACK_MOUSE_UP, _up_cb, obj);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(sd->event[i], EVAS_CALLBACK_MOUSE_MOVE, _move_cb, obj);
|
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_interaction_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Ui_Flip_Interaction mode)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2011-05-25 03:20:49 -07:00
|
|
|
int i;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
|
|
|
|
if (sd->intmode == mode) return;
|
|
|
|
sd->intmode = mode;
|
2013-11-14 01:26:04 -08:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
2016-06-06 16:50:26 -07:00
|
|
|
if (sd->intmode == EFL_UI_FLIP_INTERACTION_NONE)
|
2013-12-10 18:37:04 -08:00
|
|
|
ELM_SAFE_FREE(sd->event[i], evas_object_del);
|
|
|
|
else if (sd->dir_enabled[i])
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2013-12-10 18:37:04 -08:00
|
|
|
int area = (i & 0x2) | (i ^ 0x1);
|
|
|
|
if (sd->dir_hitsize[area] >= 0.0)
|
|
|
|
_event_rect_create(obj, sd, area);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
_sizing_eval(obj);
|
|
|
|
_configure(obj);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EOLIAN static Efl_Ui_Flip_Interaction
|
|
|
|
_efl_ui_flip_interaction_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2014-03-23 02:14:48 -07:00
|
|
|
return sd->intmode;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2016-07-19 22:24:23 -07:00
|
|
|
static int
|
|
|
|
_orient_dir_xlate(Efl_Orient dir)
|
|
|
|
{
|
|
|
|
if (dir == EFL_ORIENT_UP) return ELM_FLIP_DIRECTION_UP;
|
|
|
|
else if (dir == EFL_ORIENT_DOWN) return ELM_FLIP_DIRECTION_DOWN;
|
|
|
|
else if (dir == EFL_ORIENT_LEFT) return ELM_FLIP_DIRECTION_LEFT;
|
|
|
|
else if (dir == EFL_ORIENT_RIGHT) return ELM_FLIP_DIRECTION_RIGHT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_interaction_direction_enabled_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Orient dir, Eina_Bool enabled)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2016-07-19 22:24:23 -07:00
|
|
|
int i = _orient_dir_xlate(dir);;
|
2013-12-10 18:37:04 -08:00
|
|
|
int area;
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
enabled = !!enabled;
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->dir_enabled[i] == enabled) return;
|
|
|
|
sd->dir_enabled[i] = enabled;
|
2016-06-06 16:50:26 -07:00
|
|
|
if (sd->intmode == EFL_UI_FLIP_INTERACTION_NONE) return;
|
2013-12-10 18:37:04 -08:00
|
|
|
|
|
|
|
area = (i & 0x2) | (i ^ 0x1); // up <-> down, left <-> right
|
|
|
|
if (enabled && (sd->dir_hitsize[area] >= 0.0))
|
|
|
|
_event_rect_create(obj, sd, area);
|
|
|
|
else if (!enabled && (sd->dir_hitsize[area] <= 0.0))
|
|
|
|
// Delete this hit area as it has the default hitsize (0)
|
|
|
|
ELM_SAFE_FREE(sd->event[area], evas_object_del);
|
|
|
|
|
2011-05-24 23:06:48 -07:00
|
|
|
_sizing_eval(obj);
|
2011-05-25 03:20:49 -07:00
|
|
|
_configure(obj);
|
2011-05-24 23:06:48 -07:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_interaction_direction_enabled_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Orient dir)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2016-07-19 22:24:23 -07:00
|
|
|
return sd->dir_enabled[_orient_dir_xlate(dir)];
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_interaction_direction_hitsize_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Orient dir, double hitsize)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2016-07-19 22:24:23 -07:00
|
|
|
int i = _orient_dir_xlate(dir);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
|
|
|
|
2013-12-10 18:37:04 -08:00
|
|
|
if (hitsize < 0.0)
|
|
|
|
hitsize = -1.0;
|
2012-05-15 10:37:42 -07:00
|
|
|
else if (hitsize > 1.0)
|
|
|
|
hitsize = 1.0;
|
2013-07-26 04:03:26 -07:00
|
|
|
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->dir_hitsize[i] == hitsize) return;
|
|
|
|
sd->dir_hitsize[i] = hitsize;
|
2013-12-10 18:37:04 -08:00
|
|
|
|
|
|
|
if (hitsize >= 0.0)
|
|
|
|
_event_rect_create(obj, sd, i);
|
|
|
|
else
|
|
|
|
ELM_SAFE_FREE(sd->event[i], evas_object_del);
|
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
_sizing_eval(obj);
|
|
|
|
_configure(obj);
|
|
|
|
}
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
static void
|
|
|
|
_update_front_back(Eo *obj, Efl_Ui_Flip_Data *pd)
|
|
|
|
{
|
|
|
|
int count, index;
|
|
|
|
Efl_Gfx *content;
|
|
|
|
|
|
|
|
count = eina_list_count(pd->content_list);
|
|
|
|
if (count <= 2) return;
|
|
|
|
|
|
|
|
// update the next state object
|
|
|
|
content = _flip_content_unset(obj, !pd->state);
|
|
|
|
evas_object_hide(content);
|
|
|
|
content = pd->state ? pd->front.content : pd->back.content;
|
|
|
|
index = eina_list_data_idx(pd->content_list, content);
|
|
|
|
index = (index == count-1) ? 0 : index + 1;
|
|
|
|
content = eina_list_nth(pd->content_list, index);
|
|
|
|
evas_object_show(content);
|
|
|
|
_flip_content_set(obj, content, !pd->state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_content_added(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *content)
|
|
|
|
{
|
|
|
|
evas_object_smart_member_add(content, obj);
|
|
|
|
|
|
|
|
if (!pd->front.content)
|
|
|
|
{
|
|
|
|
_flip_content_set(obj, content, EINA_TRUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!pd->back.content)
|
|
|
|
{
|
|
|
|
_flip_content_set(obj, content, EINA_FALSE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_content_removed(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *content)
|
|
|
|
{
|
|
|
|
Efl_Gfx *back_face, *cur_face, *face;
|
|
|
|
int index, count;
|
|
|
|
Eina_Bool state;
|
|
|
|
|
|
|
|
evas_object_smart_member_del(content);
|
|
|
|
// if its not the front or back object just return.
|
|
|
|
if ((pd->front.content != content) ||
|
|
|
|
(pd->back.content != content))
|
|
|
|
return;
|
|
|
|
|
|
|
|
cur_face = pd->state ? pd->front.content : pd->back.content;
|
|
|
|
back_face = pd->state ? pd->back.content : pd->front.content;
|
|
|
|
|
|
|
|
if (cur_face == content)
|
|
|
|
{
|
|
|
|
face = back_face;
|
|
|
|
state = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
face = cur_face;
|
|
|
|
state = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
_flip_content_unset(obj, state);
|
|
|
|
|
|
|
|
count = eina_list_count(pd->content_list);
|
|
|
|
if (count == 1) return;
|
|
|
|
|
|
|
|
_flip_content_unset(obj, state);
|
|
|
|
index = eina_list_data_idx(pd->content_list, face);
|
|
|
|
index = (index == count-1) ? 0 : index + 1;
|
|
|
|
_flip_content_set(obj, eina_list_nth(pd->content_list, index), state);
|
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static double
|
2016-06-06 16:50:26 -07:00
|
|
|
_efl_ui_flip_interaction_direction_hitsize_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Orient dir)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2016-07-19 22:24:23 -07:00
|
|
|
int i = _orient_dir_xlate(dir);
|
2012-05-15 10:37:42 -07:00
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
return sd->dir_hitsize[i];
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
EOLIAN static Eina_Iterator *
|
|
|
|
_efl_ui_flip_efl_container_content_iterate(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *pd)
|
|
|
|
{
|
|
|
|
return eina_list_iterator_new(pd->content_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static int
|
|
|
|
_efl_ui_flip_efl_container_content_count(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *pd)
|
|
|
|
{
|
|
|
|
return eina_list_count(pd->content_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_container_content_remove(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *content)
|
|
|
|
{
|
|
|
|
pd->content_list = eina_list_remove(pd->content_list, content);
|
|
|
|
_content_removed(obj, pd, content);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_pack_unpack(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *subobj)
|
|
|
|
{
|
|
|
|
pd->content_list = eina_list_remove(pd->content_list, subobj);
|
|
|
|
_content_removed(obj, pd, subobj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_pack_pack(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *subobj)
|
|
|
|
{
|
|
|
|
pd->content_list = eina_list_append(pd->content_list, subobj);
|
|
|
|
_content_added(obj, pd, subobj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_begin(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *subobj)
|
|
|
|
{
|
|
|
|
pd->content_list = eina_list_prepend(pd->content_list, subobj);
|
|
|
|
_content_added(obj, pd, subobj);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_end(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *subobj)
|
|
|
|
{
|
|
|
|
pd->content_list = eina_list_append(pd->content_list, subobj);
|
|
|
|
_content_added(obj, pd, subobj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_before(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *subobj, const Efl_Gfx *existing)
|
|
|
|
{
|
|
|
|
pd->content_list = eina_list_prepend_relative(pd->content_list, subobj, existing);
|
|
|
|
_content_added(obj, pd, subobj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_after(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *subobj, const Efl_Gfx *existing)
|
|
|
|
{
|
|
|
|
pd->content_list = eina_list_append_relative(pd->content_list, subobj, existing);
|
|
|
|
_content_added(obj, pd, subobj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_at(Eo *obj, Efl_Ui_Flip_Data *pd, Efl_Gfx *subobj, int index)
|
|
|
|
{
|
|
|
|
Efl_Gfx *existing = NULL;
|
|
|
|
existing = eina_list_nth(pd->content_list, index);
|
|
|
|
pd->content_list = eina_list_prepend_relative(pd->content_list, subobj, existing);
|
|
|
|
_content_added(obj, pd, subobj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Efl_Gfx *
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_content_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *pd, int index)
|
|
|
|
{
|
|
|
|
return eina_list_nth(pd->content_list, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Efl_Gfx *
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_unpack_at(Eo *obj, Efl_Ui_Flip_Data *pd, int index)
|
|
|
|
{
|
|
|
|
Efl_Gfx *content = eina_list_nth(pd->content_list ,index);
|
|
|
|
|
|
|
|
pd->content_list = eina_list_remove(pd->content_list, content);
|
|
|
|
_content_removed(obj, pd, content);
|
|
|
|
return content;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static int
|
|
|
|
_efl_ui_flip_efl_pack_linear_pack_index_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *pd, const Efl_Gfx *subobj)
|
|
|
|
{
|
|
|
|
return eina_list_data_idx(pd->content_list, (void *)subobj);
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
2016-08-10 07:23:04 -07:00
|
|
|
_efl_ui_flip_class_constructor(Efl_Class *klass)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2014-03-23 02:14:48 -07:00
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
static Efl_Orient
|
|
|
|
_to_efl_orientation(Elm_Flip_Direction dir)
|
|
|
|
{
|
|
|
|
Efl_Orient res;
|
|
|
|
switch (dir)
|
|
|
|
{
|
|
|
|
case ELM_FLIP_DIRECTION_RIGHT:
|
|
|
|
res = EFL_ORIENT_RIGHT;
|
|
|
|
break;
|
|
|
|
case ELM_FLIP_DIRECTION_DOWN:
|
|
|
|
res = EFL_ORIENT_DOWN;
|
|
|
|
break;
|
|
|
|
case ELM_FLIP_DIRECTION_LEFT:
|
|
|
|
res = EFL_ORIENT_LEFT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
res = EFL_ORIENT_UP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_flip_interaction_direction_hitsize_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, double hitsize)
|
|
|
|
{
|
|
|
|
Efl_Orient orient = _to_efl_orientation(dir);
|
|
|
|
efl_ui_flip_interaction_direction_hitsize_set((Efl_Ui_Flip *)obj, orient, hitsize);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_flip_interaction_direction_hitsize_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir)
|
|
|
|
{
|
|
|
|
Efl_Orient orient = _to_efl_orientation(dir);
|
|
|
|
return efl_ui_flip_interaction_direction_hitsize_get((Efl_Ui_Flip *)obj, orient);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOAPI void
|
|
|
|
elm_flip_interaction_direction_enabled_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
Efl_Orient orient = _to_efl_orientation(dir);
|
|
|
|
efl_ui_flip_interaction_direction_enabled_set((Efl_Ui_Flip *)obj, orient, enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOAPI Eina_Bool
|
|
|
|
elm_flip_interaction_direction_enabled_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir)
|
|
|
|
{
|
|
|
|
Efl_Orient orient = _to_efl_orientation(dir);
|
|
|
|
return efl_ui_flip_interaction_direction_enabled_get((Efl_Ui_Flip *)obj, orient);
|
|
|
|
}
|
|
|
|
|
2016-05-24 04:40:18 -07:00
|
|
|
/* Efl.Part begin */
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
ELM_PART_IMPLEMENT(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data, Elm_Part_Data)
|
|
|
|
ELM_PART_IMPLEMENT_CONTENT_SET(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data, Elm_Part_Data)
|
|
|
|
ELM_PART_IMPLEMENT_CONTENT_GET(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data, Elm_Part_Data)
|
|
|
|
ELM_PART_IMPLEMENT_CONTENT_UNSET(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data, Elm_Part_Data)
|
|
|
|
#include "efl_ui_flip_internal_part.eo.c"
|
2016-05-24 04:40:18 -07:00
|
|
|
|
|
|
|
/* Efl.Part end */
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
#include "efl_ui_flip.eo.c"
|