2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2017-10-18 18:13:54 -07:00
|
|
|
#define EFL_ACCESS_PROTECTED
|
2014-10-17 08:56:11 -07:00
|
|
|
|
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
|
|
|
|
edje/elm: Rename _internal_ to _part_ (EO)
In Edje and Elementary, we have part objects, which are what is returned
by the interface efl_part(). Those objects can't be of an opaque type as
this doesn't work nicely with strongly typed languages such as C++ or
C#. In JS, Lua, C the types are weak and mostly runtime-based so it
doesn't matter much.
As a consequence, the documentation and the types need to look nice in
this EO API. Thus, we remove the abusive term "internal" and explicitly
call all those classes "part" something.
Eventually we want the types to be declared in the EO file so bindings
(C#, C++, ...) can generate the proper access methods, returning the
best possible types.
Note that right now a few of those part types are used in the legacy API
but don't actually need to be exposed externally.
This is kind of a mega commit that does all the renaming at once, but
it's really just a big sed operation. The power of good IDEs :)
Ref T5315
Ref T5306
2017-09-12 21:29:25 -07:00
|
|
|
#include "efl_ui_flip_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)
|
2017-09-18 00:22:01 -07:00
|
|
|
evas_object_size_hint_combined_min_get(sd->front.content, &minw, &minh);
|
2012-05-15 10:37:42 -07:00
|
|
|
if (sd->back.content)
|
2017-09-18 00:22:01 -07:00
|
|
|
evas_object_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);
|
|
|
|
}
|
|
|
|
|
2017-08-09 00:13:06 -07:00
|
|
|
EOLIAN static Efl_Ui_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
|
|
|
{
|
2017-08-09 00:13:06 -07:00
|
|
|
Efl_Ui_Theme_Apply int_ret = EFL_UI_THEME_APPLY_FAILED;
|
2016-08-15 06:44:41 -07:00
|
|
|
int_ret = elm_obj_widget_theme_apply(efl_super(obj, MY_CLASS));
|
2017-08-09 00:13:06 -07:00
|
|
|
if (!int_ret) return EFL_UI_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
|
|
|
}
|
|
|
|
|
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
|
2017-08-23 04:41:37 -07:00
|
|
|
_efl_ui_flip_elm_widget_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
|
|
|
|
2017-08-23 04:41:37 -07:00
|
|
|
int_ret = elm_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
|
2017-08-23 04:41:37 -07:00
|
|
|
_efl_ui_flip_elm_widget_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
|
|
|
|
2017-08-23 04:41:37 -07:00
|
|
|
int_ret = elm_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
|
|
|
{
|
2017-04-10 17:56:22 -07:00
|
|
|
Evas_Map *m = evas_map_dup(evas_object_map_get(sl->obj));
|
2011-05-25 03:20:49 -07:00
|
|
|
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);
|
2017-04-10 17:56:22 -07:00
|
|
|
evas_map_free(m);
|
2011-05-25 03:20:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-10-20 22:12:58 -07:00
|
|
|
static void
|
|
|
|
_cross_fade_update(Evas_Object *obj, double t)
|
|
|
|
{
|
|
|
|
int ca, cb;
|
|
|
|
Evas_Object *aclip, *bclip;
|
|
|
|
Eina_Bool front;
|
|
|
|
double s;
|
|
|
|
EFL_UI_FLIP_DATA_GET(obj, sd);
|
|
|
|
front = sd->next_state;
|
|
|
|
|
|
|
|
s = sin(t * M_PI_2); // fade in sinusoidally
|
|
|
|
t = s * s;
|
|
|
|
ca = 255 * t;
|
|
|
|
if (ca < 0) ca = 0;
|
|
|
|
if (ca > 255) ca = 255;
|
|
|
|
|
|
|
|
cb = sqrt(255 * 255 - ca * ca);
|
|
|
|
if (cb < 0) cb = 0;
|
|
|
|
if (cb > 255) cb = 255;
|
|
|
|
|
|
|
|
if (front)
|
|
|
|
{
|
|
|
|
aclip = sd->front.clip;
|
|
|
|
bclip = sd->back.clip;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
aclip = sd->back.clip;
|
|
|
|
bclip = sd->front.clip;
|
|
|
|
}
|
|
|
|
|
|
|
|
evas_object_color_set(aclip, ca, ca, ca, ca);
|
|
|
|
evas_object_color_set(bclip, cb, cb, cb, cb);
|
|
|
|
}
|
|
|
|
|
2011-05-25 03:20:49 -07:00
|
|
|
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
|
|
|
}
|
2016-10-20 22:12:58 -07:00
|
|
|
else if (sd->mode == ELM_FLIP_CROSS_FADE)
|
|
|
|
{
|
|
|
|
sd->dir = 0;
|
|
|
|
sd->started = EINA_TRUE;
|
|
|
|
sd->pageflip = EINA_FALSE;
|
|
|
|
_cross_fade_update(obj, t);
|
|
|
|
}
|
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-10-20 22:12:58 -07:00
|
|
|
|
|
|
|
if (sd->mode == ELM_FLIP_CROSS_FADE)
|
|
|
|
{
|
|
|
|
// Make the content fully opaque again
|
|
|
|
evas_object_color_set(sd->front.clip, 255, 255, 255, 255);
|
|
|
|
evas_object_color_set(sd->back.clip, 255, 255, 255, 255);
|
|
|
|
}
|
|
|
|
|
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);
|
2016-12-21 04:06:54 -08:00
|
|
|
if (efl_isa(content, ELM_WIDGET_CLASS) && sd->state != front)
|
|
|
|
elm_widget_tree_unfocusable_set(content, EINA_TRUE);
|
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);
|
|
|
|
}
|
|
|
|
|
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);
|
2017-07-06 00:47:41 -07:00
|
|
|
return efl_add(MY_CLASS, parent, efl_canvas_object_legacy_ctor(efl_added));
|
2012-11-25 22:32:53 -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
|
|
|
|
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);
|
2017-10-18 18:13:54 -07:00
|
|
|
efl_access_role_set(obj, EFL_ACCESS_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
|
|
|
{
|
2017-02-07 13:36:16 -08:00
|
|
|
EFL_UI_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);
|
|
|
|
|
|
|
|
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));
|
2016-10-20 22:12:58 -07:00
|
|
|
|
|
|
|
if (sd->mode == ELM_FLIP_CROSS_FADE)
|
|
|
|
{
|
|
|
|
// Convention: a is fading in, b is fading out
|
|
|
|
Evas_Object *a, *b;
|
|
|
|
if (front)
|
|
|
|
{
|
|
|
|
a = sd->front.content;
|
|
|
|
b = sd->back.content;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
a = sd->back.content;
|
|
|
|
b = sd->front.content;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Stack fade-in content on top of fade-out content
|
|
|
|
if (a && b) evas_object_stack_above(a, b);
|
|
|
|
|
|
|
|
evas_object_show(sd->front.clip);
|
|
|
|
evas_object_show(sd->back.clip);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_flip_show_hide(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-10-20 22:12:58 -07:00
|
|
|
|
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);
|
|
|
|
}
|
2016-12-21 04:06:54 -08:00
|
|
|
|
|
|
|
if (sd->front.content && efl_isa(sd->front.content, ELM_WIDGET_CLASS))
|
|
|
|
elm_widget_tree_unfocusable_set(sd->front.content, !front);
|
|
|
|
if (sd->back.content && efl_isa(sd->back.content, ELM_WIDGET_CLASS))
|
|
|
|
elm_widget_tree_unfocusable_set(sd->back.content, front);
|
|
|
|
|
|
|
|
|
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
|
|
|
|
2017-08-09 07:25:59 -07:00
|
|
|
static Efl_Ui_Dir
|
|
|
|
_flip_dir_to_efl_ui_dir(Elm_Flip_Direction dir)
|
|
|
|
{
|
|
|
|
switch (dir)
|
|
|
|
{
|
|
|
|
case ELM_FLIP_DIRECTION_RIGHT: return EFL_UI_DIR_RIGHT;
|
|
|
|
case ELM_FLIP_DIRECTION_DOWN: return EFL_UI_DIR_DOWN;
|
|
|
|
case ELM_FLIP_DIRECTION_LEFT: return EFL_UI_DIR_LEFT;
|
|
|
|
case ELM_FLIP_DIRECTION_UP: return EFL_UI_DIR_UP;
|
|
|
|
}
|
|
|
|
ERR("Invalid value for Elm_Flip_Direction: %d", (int) dir);
|
|
|
|
return EFL_UI_DIR_DEFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Elm_Flip_Direction
|
|
|
|
_efl_ui_dir_to_flip_dir(Efl_Ui_Dir dir)
|
2016-07-19 22:24:23 -07:00
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
switch (dir)
|
|
|
|
{
|
|
|
|
case EFL_UI_DIR_RIGHT:
|
|
|
|
case EFL_UI_DIR_HORIZONTAL:
|
|
|
|
return ELM_FLIP_DIRECTION_RIGHT;
|
|
|
|
case EFL_UI_DIR_DOWN:
|
|
|
|
return ELM_FLIP_DIRECTION_DOWN;
|
|
|
|
case EFL_UI_DIR_LEFT:
|
|
|
|
return ELM_FLIP_DIRECTION_LEFT;
|
|
|
|
case EFL_UI_DIR_UP:
|
|
|
|
case EFL_UI_DIR_VERTICAL:
|
|
|
|
case EFL_UI_DIR_DEFAULT:
|
|
|
|
return ELM_FLIP_DIRECTION_UP;
|
|
|
|
}
|
|
|
|
ERR("Invalid value for Efl_Ui_Dir: %d", (int) dir);
|
|
|
|
return ELM_FLIP_DIRECTION_UP;
|
2016-07-19 22:24:23 -07:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2017-08-09 07:25:59 -07:00
|
|
|
_efl_ui_flip_interaction_direction_enabled_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir, Eina_Bool enabled)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
int i = _efl_ui_dir_to_flip_dir(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
|
2017-08-09 07:25:59 -07:00
|
|
|
_efl_ui_flip_interaction_direction_enabled_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir)
|
2011-05-24 23:06:48 -07:00
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
return sd->dir_enabled[_efl_ui_dir_to_flip_dir(dir)];
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-23 02:14:48 -07:00
|
|
|
EOLIAN static void
|
2017-08-09 07:25:59 -07:00
|
|
|
_efl_ui_flip_interaction_direction_hitsize_set(Eo *obj, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir, double hitsize)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
int i = _efl_ui_dir_to_flip_dir(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);
|
2017-09-25 08:54:12 -07:00
|
|
|
// if its not the front or back object just return.
|
2016-06-06 16:50:26 -07:00
|
|
|
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
|
2017-08-09 07:25:59 -07:00
|
|
|
_efl_ui_flip_interaction_direction_hitsize_get(Eo *obj EINA_UNUSED, Efl_Ui_Flip_Data *sd, Efl_Ui_Dir dir)
|
2011-05-25 03:20:49 -07:00
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
int i = _efl_ui_dir_to_flip_dir(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
|
|
|
|
2017-09-25 08:54:12 -07:00
|
|
|
EAPI void
|
2016-06-06 16:50:26 -07:00
|
|
|
elm_flip_interaction_direction_hitsize_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, double hitsize)
|
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
|
|
|
|
efl_ui_flip_interaction_direction_hitsize_set(obj, uidir, hitsize);
|
2016-06-06 16:50:26 -07:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:54:12 -07:00
|
|
|
EAPI double
|
2016-06-06 16:50:26 -07:00
|
|
|
elm_flip_interaction_direction_hitsize_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir)
|
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
|
|
|
|
return efl_ui_flip_interaction_direction_hitsize_get(obj, uidir);
|
2016-06-06 16:50:26 -07:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:54:12 -07:00
|
|
|
EOAPI void
|
2016-06-06 16:50:26 -07:00
|
|
|
elm_flip_interaction_direction_enabled_set(Efl_Ui_Flip *obj, Elm_Flip_Direction dir, Eina_Bool enabled)
|
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
|
|
|
|
efl_ui_flip_interaction_direction_enabled_set(obj, uidir, enabled);
|
2016-06-06 16:50:26 -07:00
|
|
|
}
|
|
|
|
|
2017-09-25 08:54:12 -07:00
|
|
|
EOAPI Eina_Bool
|
2016-06-06 16:50:26 -07:00
|
|
|
elm_flip_interaction_direction_enabled_get(Efl_Ui_Flip *obj, Elm_Flip_Direction dir)
|
|
|
|
{
|
2017-08-09 07:25:59 -07:00
|
|
|
Efl_Ui_Dir uidir = _flip_dir_to_efl_ui_dir(dir);
|
|
|
|
return efl_ui_flip_interaction_direction_enabled_get(obj, uidir);
|
2016-06-06 16:50:26 -07:00
|
|
|
}
|
|
|
|
|
2016-05-24 04:40:18 -07:00
|
|
|
/* Efl.Part begin */
|
|
|
|
|
2017-09-19 04:02:26 -07:00
|
|
|
ELM_PART_OVERRIDE(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data)
|
|
|
|
ELM_PART_OVERRIDE_CONTENT_SET(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data)
|
|
|
|
ELM_PART_OVERRIDE_CONTENT_GET(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data)
|
|
|
|
ELM_PART_OVERRIDE_CONTENT_UNSET(efl_ui_flip, EFL_UI_FLIP, Efl_Ui_Flip_Data)
|
2017-06-29 04:02:59 -07:00
|
|
|
ELM_PART_CONTENT_DEFAULT_SET(efl_ui_flip, "front")
|
edje/elm: Rename _internal_ to _part_ (EO)
In Edje and Elementary, we have part objects, which are what is returned
by the interface efl_part(). Those objects can't be of an opaque type as
this doesn't work nicely with strongly typed languages such as C++ or
C#. In JS, Lua, C the types are weak and mostly runtime-based so it
doesn't matter much.
As a consequence, the documentation and the types need to look nice in
this EO API. Thus, we remove the abusive term "internal" and explicitly
call all those classes "part" something.
Eventually we want the types to be declared in the EO file so bindings
(C#, C++, ...) can generate the proper access methods, returning the
best possible types.
Note that right now a few of those part types are used in the legacy API
but don't actually need to be exposed externally.
This is kind of a mega commit that does all the renaming at once, but
it's really just a big sed operation. The power of good IDEs :)
Ref T5315
Ref T5306
2017-09-12 21:29:25 -07:00
|
|
|
#include "efl_ui_flip_part.eo.c"
|
2016-05-24 04:40:18 -07:00
|
|
|
|
|
|
|
/* Efl.Part end */
|
|
|
|
|
2017-05-18 01:52:17 -07:00
|
|
|
/* Internal EO APIs and hidden overrides */
|
|
|
|
|
|
|
|
#define EFL_UI_FLIP_EXTRA_OPS \
|
2017-06-29 04:02:59 -07:00
|
|
|
ELM_PART_CONTENT_DEFAULT_OPS(efl_ui_flip), \
|
2017-05-18 01:52:17 -07:00
|
|
|
EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_flip)
|
|
|
|
|
2016-06-06 16:50:26 -07:00
|
|
|
#include "efl_ui_flip.eo.c"
|