src/lib/elm_flip.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 typedef struct _Widget_Data Widget_Data;
   5 typedef struct _Slice Slice;
   6 typedef struct _Vertex2 Vertex2;
   7 typedef struct _Vertex3 Vertex3;
   8
   9 struct _Slice
  10 {
  11    Evas_Object *obj;
  12    double u[4], v[4], x[4], y[4], z[4];
  13 };
  14
  15 struct _Vertex2
  16 {
  17    double x, y;
  18 };
  19
  20 struct _Vertex3
  21 {
  22    double x, y, z;
  23 };
  24
  25 struct _Widget_Data
  26 {
  27    Evas_Object *obj;
  28    Ecore_Animator *animator;
  29    double start, len;
  30    Elm_Flip_Mode mode;
  31    Evas_Object *clip;
  32    Evas_Object *event[4];
  33    struct
  34      {
  35         Evas_Object *content, *clip;
  36      } front, back;
  37    Ecore_Job *job;
  38    Evas_Coord down_x, down_y, x, y, ox, oy, w, h;
  39    Elm_Flip_Interaction intmode;
  40    int dir;
  41    double    dir_hitsize[4];
  42    Eina_Bool dir_enabled[4];
  43    int slices_w, slices_h;
  44    Slice **slices, **slices2;
  45
  46    Eina_Bool state : 1;
  47    Eina_Bool down : 1;
  48    Eina_Bool finish : 1;
  49    Eina_Bool started : 1;
  50    Eina_Bool backflip : 1;
  51    Eina_Bool pageflip : 1;
  52 };
  53
  54 static const char *widtype = NULL;
  55 static void _del_hook(Evas_Object *obj);
  56 static void _theme_hook(Evas_Object *obj);
  57 static void _sizing_eval(Evas_Object *obj);
  58 static void _changed_size_hints(void *data, Evas *e, Evas_Object *obj, void *event_info);
  59 static void _sub_del(void *data, Evas_Object *obj, void *event_info);
  60
  61 static void _state_slices_clear(Widget_Data *st);
  62 static void _configure(Evas_Object *obj);
  63
  64 static const char SIG_ANIMATE_BEGIN[] = "animate,begin";
  65 static const char SIG_ANIMATE_DONE[] = "animate,done";
  66
  67 static const Evas_Smart_Cb_Description _signals[] = {
  68    {SIG_ANIMATE_BEGIN, ""},
  69    {SIG_ANIMATE_DONE, ""},
  70    {NULL, NULL}
  71 };
  72
  73 static void
  74 _del_hook(Evas_Object *obj)
  75 {
  76    Widget_Data *wd = elm_widget_data_get(obj);
  77    if (!wd) return;
  78    if (wd->animator) ecore_animator_del(wd->animator);
  79    _state_slices_clear(wd);
  80    free(wd);
  81 }
  82
  83 static void
  84 _theme_hook(Evas_Object *obj)
  85 {
  86    Widget_Data *wd = elm_widget_data_get(obj);
  87    if (!wd) return;
  88    _sizing_eval(obj);
  89 }
  90
  91 static Eina_Bool
  92 _elm_flip_focus_next_hook(const Evas_Object *obj,
  93                           Elm_Focus_Direction dir, Evas_Object **next)
  94 {
  95    Widget_Data *wd = elm_widget_data_get(obj);
  96    if (!wd) return EINA_FALSE;
  97
  98    /* Try Focus cycle in subitem */
  99    if (wd->state)
 100      return elm_widget_focus_next_get(wd->front.content, dir, next);
 101    else
 102      return elm_widget_focus_next_get(wd->back.content, dir, next);
 103 }
 104
 105 static void
 106 _sizing_eval(Evas_Object *obj)
 107 {
 108    Widget_Data *wd = elm_widget_data_get(obj);
 109    Evas_Coord minw = -1, minh = -1, minw2 = -1, minh2 = -1;
 110    Evas_Coord maxw = -1, maxh = -1, maxw2 = -1, maxh2 = -1;
 111    int fingx = 0, fingy = 0;
 112    if (!wd) return;
 113    if (wd->front.content)
 114      evas_object_size_hint_min_get(wd->front.content, &minw, &minh);
 115    if (wd->back.content)
 116      evas_object_size_hint_min_get(wd->back.content, &minw2, &minh2);
 117    if (wd->front.content)
 118      evas_object_size_hint_max_get(wd->front.content, &maxw, &maxh);
 119    if (wd->back.content)
 120      evas_object_size_hint_max_get(wd->back.content, &maxw2, &maxh2);
 121
 122    if (minw2 > minw) minw = minw2;
 123    if (minh2 > minh) minh = minh2;
 124    if ((maxw2 >= 0) && (maxw2 < maxw)) maxw = maxw2;
 125    if ((maxh2 >= 0) && (maxh2 < maxh)) maxh = maxh2;
 126
 127    if (wd->dir_enabled[0]) fingy++;
 128    if (wd->dir_enabled[1]) fingy++;
 129    if (wd->dir_enabled[2]) fingx++;
 130    if (wd->dir_enabled[3]) fingx++;
 131
 132    elm_coords_finger_size_adjust(fingx, &minw, fingy, &minh);
 133
 134    evas_object_size_hint_min_set(obj, minw, minh);
 135    evas_object_size_hint_max_set(obj, maxw, maxh);
 136 }
 137
 138 static void
 139 _changed_size_hints(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 140 {
 141    Widget_Data *wd = elm_widget_data_get(data);
 142    if (!wd) return;
 143    _sizing_eval(data);
 144 }
 145
 146 static void
 147 _sub_del(void *data __UNUSED__, Evas_Object *obj, void *event_info)
 148 {
 149    Widget_Data *wd = elm_widget_data_get(obj);
 150    Evas_Object *sub = event_info;
 151    if (!wd) return;
 152    if (sub == wd->front.content)
 153      {
 154         evas_object_event_callback_del_full(sub,
 155                                             EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 156                                             _changed_size_hints, obj);
 157         wd->front.content = NULL;
 158         evas_object_hide(wd->front.clip);
 159         _sizing_eval(obj);
 160      }
 161    else if (sub == wd->back.content)
 162      {
 163         evas_object_event_callback_del_full(sub,
 164                                             EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 165                                             _changed_size_hints, obj);
 166         wd->back.content = NULL;
 167         evas_object_hide(wd->back.clip);
 168         _sizing_eval(obj);
 169      }
 170 }
 171
 172 static Slice *
 173 _slice_new(Widget_Data *st __UNUSED__, Evas_Object *obj)
 174 {
 175    Slice *sl;
 176
 177    sl = calloc(1, sizeof(Slice));
 178    if (!sl) return NULL;
 179    sl->obj = evas_object_image_add(evas_object_evas_get(obj));
 180    elm_widget_sub_object_add(st->obj, sl->obj);
 181    evas_object_clip_set(sl->obj, evas_object_clip_get(st->obj));
 182    evas_object_smart_member_add(sl->obj, st->obj);
 183    evas_object_image_smooth_scale_set(sl->obj, EINA_FALSE);
 184    evas_object_pass_events_set(sl->obj, EINA_TRUE);
 185    evas_object_image_source_set(sl->obj, obj);
 186    return sl;
 187 }
 188
 189 static void
 190 _slice_free(Slice *sl)
 191 {
 192    evas_object_del(sl->obj);
 193    free(sl);
 194 }
 195
 196 static void
 197 _slice_apply(Widget_Data *st, Slice *sl, Evas_Coord x __UNUSED__,
 198              Evas_Coord y __UNUSED__, Evas_Coord w, Evas_Coord h __UNUSED__,
 199              Evas_Coord ox, Evas_Coord oy, Evas_Coord ow, Evas_Coord oh)
 200 {
 201    Evas_Map *m;
 202    int i;
 203
 204    m = evas_map_new(4);
 205    if (!m) return;
 206    evas_map_smooth_set(m, EINA_FALSE);
 207    for (i = 0; i < 4; i++)
 208      {
 209         evas_map_point_color_set(m, i, 255, 255, 255, 255);
 210         if (st->dir == 0)
 211           {
 212              int p[4] = { 0, 1, 2, 3 };
 213              evas_map_point_coord_set(m, i, ox + sl->x[p[i]], oy + sl->y[p[i]],
 214                                       sl->z[p[i]]);
 215              evas_map_point_image_uv_set(m, i, sl->u[p[i]] , sl->v[p[i]]);
 216           }
 217         else if (st->dir == 1)
 218           {
 219              int p[4] = { 1, 0, 3, 2 };
 220              evas_map_point_coord_set(m, i, ox + (w - sl->x[p[i]]),
 221                                       oy + sl->y[p[i]], sl->z[p[i]]);
 222              evas_map_point_image_uv_set(m, i, ow - sl->u[p[i]], sl->v[p[i]]);
 223           }
 224         else if (st->dir == 2)
 225           {
 226              int p[4] = { 1, 0, 3, 2 };
 227              evas_map_point_coord_set(m, i, ox + sl->y[p[i]], oy + sl->x[p[i]],
 228                                       sl->z[p[i]]);
 229              evas_map_point_image_uv_set(m, i, sl->v[p[i]] , sl->u[p[i]]);
 230           }
 231         else/* if (st->dir == 3) will be this anyway */
 232           {
 233              int p[4] = { 0, 1, 2, 3 };
 234              evas_map_point_coord_set(m, i, ox + sl->y[p[i]],
 235                                       oy + (w - sl->x[p[i]]), sl->z[p[i]]);
 236              evas_map_point_image_uv_set(m, i, sl->v[p[i]] , oh - sl->u[p[i]]);
 237           }
 238      }
 239    evas_object_map_enable_set(sl->obj, EINA_TRUE);
 240    evas_object_image_fill_set(sl->obj, 0, 0, ow, oh);
 241    evas_object_map_set(sl->obj, m);
 242    evas_map_free(m);
 243 }
 244
 245 static void
 246 _slice_3d(Widget_Data *st __UNUSED__, Slice *sl, Evas_Coord x, Evas_Coord y,
 247           Evas_Coord w, Evas_Coord h)
 248 {
 249    Evas_Map *m = (Evas_Map *)evas_object_map_get(sl->obj);
 250    int i;
 251
 252    if (!m) return;
 253    // vanishing point is center of page, and focal dist is 1024
 254    evas_map_util_3d_perspective(m, x + (w / 2), y + (h / 2), 0, 1024);
 255    for (i = 0; i < 4; i++)
 256      {
 257         Evas_Coord xx, yy, zz;
 258         evas_map_point_coord_get(m, i, &xx, &yy, &zz);
 259         evas_map_point_coord_set(m, i, xx, yy, 0);
 260      }
 261    if (evas_map_util_clockwise_get(m)) evas_object_show(sl->obj);
 262    else evas_object_hide(sl->obj);
 263    evas_object_map_set(sl->obj, m);
 264 }
 265
 266 static void
 267 _slice_light(Widget_Data *st __UNUSED__, Slice *sl, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
 268 {
 269    Evas_Map *m = (Evas_Map *)evas_object_map_get(sl->obj);
 270    int i;
 271
 272    if (!m) return;
 273    evas_map_util_3d_lighting(m,
 274                              // light position
 275                              // (centered over page 10 * h toward camera)
 276                              x + (w / 2)  , y + (h / 2)  , -10000,
 277                              255, 255, 255, // light color
 278                              0 , 0 , 0); // ambient minimum
 279    // multiply brightness by 1.2 to make lightish bits all white so we dont
 280    // add shading where we could otherwise be pure white
 281    for (i = 0; i < 4; i++)
 282      {
 283         int r, g, b, a;
 284
 285         evas_map_point_color_get(m, i, &r, &g, &b, &a);
 286         r = (double)r * 1.2; if (r > 255) r = 255;
 287         g = (double)g * 1.2; if (g > 255) g = 255;
 288         b = (double)b * 1.2; if (b > 255) b = 255;
 289         evas_map_point_color_set(m, i, r, g, b, a);
 290      }
 291    evas_object_map_set(sl->obj, m);
 292 }
 293
 294 static void
 295 _slice_xyz(Widget_Data *st __UNUSED__, Slice *sl,
 296            double xx1, double yy1, double zz1,
 297            double xx2, double yy2, double zz2,
 298            double xx3, double yy3, double zz3,
 299            double xx4, double yy4, double zz4)
 300 {
 301    sl->x[0] = xx1; sl->y[0] = yy1; sl->z[0] = zz1;
 302    sl->x[1] = xx2; sl->y[1] = yy2; sl->z[1] = zz2;
 303    sl->x[2] = xx3; sl->y[2] = yy3; sl->z[2] = zz3;
 304    sl->x[3] = xx4; sl->y[3] = yy4; sl->z[3] = zz4;
 305 }
 306
 307 static void
 308 _slice_uv(Widget_Data *st __UNUSED__, Slice *sl,
 309           double u1, double v1,
 310           double u2, double v2,
 311           double u3, double v3,
 312           double u4, double v4)
 313 {
 314    sl->u[0] = u1; sl->v[0] = v1;
 315    sl->u[1] = u2; sl->v[1] = v2;
 316    sl->u[2] = u3; sl->v[2] = v3;
 317    sl->u[3] = u4; sl->v[3] = v4;
 318 }
 319
 320 static void
 321 _deform_point(Vertex2 *vi, Vertex3 *vo, double rho, double theta, double A)
 322 {
 323    // ^Y
 324    // |
 325    // |    X
 326    // +---->
 327    // theta == cone angle (0 -> PI/2)
 328    // A     == distance of cone apex from origin
 329    // rho   == angle of cone from vertical axis (...-PI/2 to PI/2...)
 330    Vertex3  v1;
 331    double d, r, b;
 332
 333    d = sqrt((vi->x * vi->x) + pow(vi->y - A, 2));
 334    r = d * sin(theta);
 335    b = asin(vi->x / d) / sin(theta);
 336
 337    v1.x = r * sin(b);
 338    v1.y = d + A - (r * (1 - cos(b)) * sin(theta));
 339    v1.z = r * (1 - cos(b)) * cos(theta);
 340
 341    vo->x = (v1.x * cos(rho)) - (v1.z * sin(rho));
 342    vo->y = v1.y;
 343    vo->z = (v1.x * sin(rho)) + (v1.z * cos(rho));
 344 }
 345
 346 static void
 347 _interp_point(Vertex3 *vi1, Vertex3 *vi2, Vertex3 *vo, double v)
 348 {
 349    vo->x = (v * vi2->x) + ((1.0 - v) * vi1->x);
 350    vo->y = (v * vi2->y) + ((1.0 - v) * vi1->y);
 351    vo->z = (v * vi2->z) + ((1.0 - v) * vi1->z);
 352 }
 353
 354 static void
 355 _state_slices_clear(Widget_Data *st)
 356 {
 357    int i, j, num;
 358
 359    if (st->slices)
 360      {
 361         num = 0;
 362         for (j = 0; j < st->slices_h; j++)
 363           {
 364              for (i = 0; i < st->slices_w; i++)
 365                {
 366                   if (st->slices[num]) _slice_free(st->slices[num]);
 367                   if (st->slices2[num]) _slice_free(st->slices2[num]);
 368                   num++;
 369                }
 370           }
 371         free(st->slices);
 372         free(st->slices2);
 373         st->slices = NULL;
 374         st->slices2 = NULL;
 375      }
 376    st->slices_w = 0;
 377    st->slices_h = 0;
 378 }
 379
 380 static int
 381 _slice_obj_color_sum(Slice *s, int p, int *r, int *g, int *b, int *a)
 382 {
 383    Evas_Map *m;
 384    int rr = 0, gg = 0, bb = 0, aa = 0;
 385
 386    if (!s) return 0;
 387    m = (Evas_Map *)evas_object_map_get(s->obj);
 388    if (!m) return 0;
 389    evas_map_point_color_get(m, p, &rr, &gg, &bb, &aa);
 390    *r += rr; *g += gg; *b += bb; *a += aa;
 391    return 1;
 392 }
 393
 394 static void
 395 _slice_obj_color_set(Slice *s, int p, int r, int g, int b, int a)
 396 {
 397    Evas_Map *m;
 398
 399    if (!s) return;
 400    m = (Evas_Map *) evas_object_map_get(s->obj);
 401    if (!m) return;
 402    evas_map_point_color_set(m, p, r, g, b, a);
 403    evas_object_map_set(s->obj, m);
 404 }
 405
 406 static void
 407 _slice_obj_vert_color_merge(Slice *s1, int p1, Slice *s2, int p2,
 408                             Slice *s3, int p3, Slice *s4, int p4)
 409 {
 410    int r = 0, g = 0, b = 0, a = 0, n = 0;
 411
 412    n += _slice_obj_color_sum(s1, p1, &r, &g, &b, &a);
 413    n += _slice_obj_color_sum(s2, p2, &r, &g, &b, &a);
 414    n += _slice_obj_color_sum(s3, p3, &r, &g, &b, &a);
 415    n += _slice_obj_color_sum(s4, p4, &r, &g, &b, &a);
 416
 417    if (n < 1) return;
 418    r /= n; g /= n; b /= n; a /= n;
 419
 420    _slice_obj_color_set(s1, p1, r, g, b, a);
 421    _slice_obj_color_set(s2, p2, r, g, b, a);
 422    _slice_obj_color_set(s3, p3, r, g, b, a);
 423    _slice_obj_color_set(s4, p4, r, g, b, a);
 424 }
 425
 426 static int
 427 _state_update(Widget_Data *st)
 428 {
 429    Evas_Coord xx1, yy1, xx2, yy2, mx, my;
 430    Evas_Coord x, y, w, h, ox, oy, ow, oh;
 431    int i, j, num, nn, jump, num2;
 432    Slice *sl;
 433    double b, minv = 0.0, minva, mgrad;
 434    int gx, gy, gszw, gszh, gw, gh, col, row, nw, nh;
 435    double rho, A, theta, perc, percm, n, rhol, Al, thetal;
 436    Vertex3 *tvo, *tvol;
 437    Evas_Object *front, *back;
 438
 439    st->backflip = EINA_TRUE;
 440    if (st->state)
 441      {
 442         front = st->front.content;
 443         back = st->front.content;
 444      }
 445    else
 446      {
 447         front = st->back.content;
 448         back = st->back.content;
 449      }
 450
 451    evas_object_geometry_get(st->obj, &x, &y, &w, &h);
 452    ox = x; oy = y; ow = w; oh = h;
 453    xx1 = st->down_x;
 454    yy1 = st->down_y;
 455    xx2 = st->x;
 456    yy2 = st->y;
 457
 458    if (st->dir == 0)
 459      {
 460         // no nothing. left drag is standard
 461      }
 462    else if (st->dir == 1)
 463      {
 464         xx1 = (w - 1) - xx1;
 465         xx2 = (w - 1) - xx2;
 466      }
 467    else if (st->dir == 2)
 468      {
 469         Evas_Coord tmp;
 470
 471         tmp = xx1; xx1 = yy1; yy1 = tmp;
 472         tmp = xx2; xx2 = yy2; yy2 = tmp;
 473         tmp = w; w = h; h = tmp;
 474      }
 475    else/* if (st->dir == 3) will be this anyway */
 476      {
 477         Evas_Coord tmp;
 478
 479         tmp = xx1; xx1 = yy1; yy1 = tmp;
 480         tmp = xx2; xx2 = yy2; yy2 = tmp;
 481         tmp = w; w = h; h = tmp;
 482         xx1 = (w - 1) - xx1;
 483         xx2 = (w - 1) - xx2;
 484      }
 485
 486    if (xx2 >= xx1) xx2 = xx1 - 1;
 487    mx = (xx1 + xx2) / 2;
 488    my = (yy1 + yy2) / 2;
 489
 490    if (mx < 0) mx = 0;
 491    else if (mx >= w) mx = w - 1;
 492    if (my < 0) my = 0;
 493    else if (my >= h) my = h - 1;
 494
 495    mgrad = (double)(yy1 - yy2) / (double)(xx1 - xx2);
 496
 497    if (mx < 1) mx = 1; // quick hack to keep curl line visible
 498
 499    if (mgrad == 0.0) // special horizontal case
 500       mgrad = 0.001; // quick dirty hack for now
 501    // else
 502      {
 503         minv = 1.0 / mgrad;
 504         // y = (m * x) + b
 505         b = my + (minv * mx);
 506      }
 507    if ((b >= -5) && (b <= (h + 5)))
 508      {
 509         if (minv > 0.0) // clamp to h
 510           {
 511              minv = (double)(h + 5 - my) / (double)(mx);
 512              b = my + (minv * mx);
 513           }
 514         else // clamp to 0
 515           {
 516              minv = (double)(-5 - my) / (double)(mx);
 517              b = my + (minv * mx);
 518           }
 519      }
 520
 521    perc = (double)xx2 / (double)xx1;
 522    percm = (double)mx / (double)xx1;
 523    if (perc < 0.0) perc = 0.0;
 524    else if (perc > 1.0) perc = 1.0;
 525    if (percm < 0.0) percm = 0.0;
 526    else if (percm > 1.0) percm = 1.0;
 527
 528    minva = atan(minv) / (M_PI / 2);
 529    if (minva < 0.0) minva = -minva;
 530
 531    // A = apex of cone
 532    if (b <= 0) A = b;
 533    else A = h - b;
 534    if (A < -(h * 20)) A = -h * 20;
 535    //--//
 536    Al = -5;
 537
 538    // rho = is how much the page is turned
 539    n = 1.0 - perc;
 540    n = 1.0 - cos(n * M_PI / 2.0);
 541    n = n * n;
 542    rho = -(n * M_PI);
 543    //--//
 544    rhol = -(n * M_PI);
 545
 546    // theta == curliness (how much page culrs in on itself
 547    n = sin((1.0 - perc) * M_PI);
 548    n = n * 1.2;
 549    theta = 7.86 + n;
 550    //--//
 551    n = sin((1.0 - perc) * M_PI);
 552    n = 1.0 - n;
 553    n = n * n;
 554    n = 1.0 - n;
 555    thetal = 7.86 + n;
 556
 557    nw = 16;
 558    nh = 16;
 559    gszw = w / nw;
 560    gszh = h / nh;
 561    if (gszw < 4) gszw = 4;
 562    if (gszh < 4) gszh = 4;
 563
 564    nw = (w + gszw - 1) / gszw;
 565    nh = (h + gszh - 1) / gszh;
 566    if ((st->slices_w != nw) || (st->slices_h != nh)) _state_slices_clear(st);
 567    st->slices_w = nw;
 568    st->slices_h = nh;
 569    if (!st->slices)
 570      {
 571         st->slices = calloc(st->slices_w * st->slices_h, sizeof(Slice *));
 572         if (!st->slices) return 0;
 573         st->slices2 = calloc(st->slices_w * st->slices_h, sizeof(Slice *));
 574         if (!st->slices2)
 575           {
 576              free(st->slices);
 577              st->slices = NULL;
 578              return 0;
 579           }
 580      }
 581
 582    num = (st->slices_w + 1) * (st->slices_h + 1);
 583
 584    tvo = alloca(sizeof(Vertex3) * num);
 585    tvol = alloca(sizeof(Vertex3) * (st->slices_w + 1));
 586
 587    for (col = 0, gx = 0; gx <= (w + gszw - 1); gx += gszw, col++)
 588      {
 589         Vertex2 vil;
 590
 591         vil.x = gx;
 592         vil.y = h - ((gx * h) / (w + gszw - 1));
 593         _deform_point(&vil, &(tvol[col]), rhol, thetal, Al);
 594      }
 595
 596    n = minva * sin(perc * M_PI);
 597    n = n * n;
 598
 599    num = 0;
 600    for (col = 0, gx = 0; gx <= (w + gszw - 1); gx += gszw, col++)
 601      {
 602         for (gy = 0; gy <= (h + gszh - 1); gy += gszh)
 603           {
 604              Vertex2 vi;
 605              Vertex3 vo, tvo1;
 606
 607              if (gx > w) vi.x = w;
 608              else vi.x = gx;
 609              if (gy > h) vi.y = h;
 610              else vi.y = gy;
 611              _deform_point(&vi, &vo, rho, theta, A);
 612              tvo1 = tvol[col];
 613              if (gy > h) tvo1.y = h;
 614              else tvo1.y = gy;
 615              _interp_point(&vo, &tvo1, &(tvo[num]), n);
 616              num++;
 617           }
 618      }
 619
 620    jump = st->slices_h + 1;
 621    for (col = 0, gx = 0; gx < w; gx += gszw, col++)
 622      {
 623         num = st->slices_h * col;
 624         num2 = jump * col;
 625
 626         gw = gszw;
 627         if ((gx + gw) > w) gw = w - gx;
 628
 629         for (row = 0, gy = 0; gy < h; gy += gszh, row++)
 630           {
 631              Vertex3 vo[4];
 632
 633              if (b > 0) nn = num + st->slices_h - row - 1;
 634              else nn = num + row;
 635
 636              gh = gszh;
 637              if ((gy + gh) > h) gh = h - gy;
 638
 639              vo[0] = tvo[num2 + row];
 640              vo[1] = tvo[num2 + row + jump];
 641              vo[2] = tvo[num2 + row + jump + 1];
 642              vo[3] = tvo[num2 + row + 1];
 643 #define SWP(a, b) do {typeof(a) vt; vt = (a); (a) = (b); (b) = vt;} while (0)
 644              if (b > 0)
 645                {
 646                   SWP(vo[0], vo[3]);
 647                   SWP(vo[1], vo[2]);
 648                   vo[0].y = h - vo[0].y;
 649                   vo[1].y = h - vo[1].y;
 650                   vo[2].y = h - vo[2].y;
 651                   vo[3].y = h - vo[3].y;
 652                }
 653
 654              // FRONT
 655              sl = st->slices[nn];
 656              if (!sl)
 657                {
 658                   sl = _slice_new(st, front);
 659                   st->slices[nn] = sl;
 660                }
 661              _slice_xyz(st, sl,
 662                         vo[0].x, vo[0].y, vo[0].z,
 663                         vo[1].x, vo[1].y, vo[1].z,
 664                         vo[2].x, vo[2].y, vo[2].z,
 665                         vo[3].x, vo[3].y, vo[3].z);
 666              if (b <= 0)
 667                _slice_uv(st, sl,
 668                          gx, gy, gx + gw,  gy,  gx + gw,  gy + gh, gx, gy + gh);
 669              else
 670                _slice_uv(st, sl,
 671                          gx, h - (gy + gh), gx + gw, h - (gy + gh), gx + gw,
 672                          h - gy, gx, h - gy);
 673
 674              // BACK
 675              sl = st->slices2[nn];
 676              if (!sl)
 677                {
 678                   sl = _slice_new(st, back);
 679                   st->slices2[nn] = sl;
 680                }
 681
 682              _slice_xyz(st, sl,
 683                         vo[1].x, vo[1].y, vo[1].z,
 684                         vo[0].x, vo[0].y, vo[0].z,
 685                         vo[3].x, vo[3].y, vo[3].z,
 686                         vo[2].x, vo[2].y, vo[2].z);
 687              if (st->backflip)
 688                {
 689                   if (b <= 0)
 690                     _slice_uv(st, sl, gx + gw, gy, gx, gy, gx, gy + gh, gx + gw,
 691                               gy + gh);
 692                   else
 693                     _slice_uv(st, sl, gx + gw, h - (gy + gh), gx, h - (gy + gh),
 694                               gx, h - gy, gx + gw, h - gy);
 695                }
 696              else
 697                {
 698                   if (b <= 0)
 699                     _slice_uv(st, sl, w - (gx + gw), gy, w - (gx), gy, w - (gx),
 700                               gy + gh, w - (gx + gw), gy + gh);
 701                   else
 702                     _slice_uv(st, sl, w - (gx + gw), h - (gy + gh), w - (gx),
 703                               h - (gy + gh),  w - (gx), h - gy, w - (gx + gw),
 704                               h - gy);
 705                }
 706           }
 707      }
 708
 709    num = 0;
 710    for (j = 0; j < st->slices_h; j++)
 711      {
 712         for (i = 0; i < st->slices_w; i++)
 713           {
 714              _slice_apply(st, st->slices[num], x, y, w, h, ox, oy, ow, oh);
 715              _slice_apply(st, st->slices2[num], x, y, w, h, ox, oy, ow, oh);
 716              _slice_light(st, st->slices[num], ox, oy, ow, oh);
 717              _slice_light(st, st->slices2[num], ox, oy, ow, oh);
 718              num++;
 719           }
 720      }
 721
 722    for (i = 0; i <= st->slices_w; i++)
 723      {
 724         num = i * st->slices_h;
 725         for (j = 0; j <= st->slices_h; j++)
 726           {
 727              Slice *s[4];
 728
 729              s[0] = s[1] = s[2] = s[3] = NULL;
 730              if ((i > 0) && (j > 0))
 731                 s[0] = st->slices[num - 1 - st->slices_h];
 732              if ((i < st->slices_w) && (j > 0))
 733                 s[1] = st->slices[num - 1];
 734              if ((i > 0) && (j < st->slices_h))
 735                 s[2] = st->slices[num - st->slices_h];
 736              if ((i < st->slices_w) && (j < st->slices_h))
 737                 s[3] = st->slices[num];
 738              if (st->dir == 0)
 739                 _slice_obj_vert_color_merge(s[0], 2, s[1], 3, s[2], 1, s[3], 0);
 740              else if (st->dir == 1)
 741                 _slice_obj_vert_color_merge(s[0], 3, s[1], 2, s[2], 0, s[3], 1);
 742              else if (st->dir == 2)
 743                 _slice_obj_vert_color_merge(s[0], 3, s[1], 2, s[2], 0, s[3], 1);
 744              else/* if (st->dir == 3) will be this anyway */
 745                 _slice_obj_vert_color_merge(s[0], 2, s[1], 3, s[2], 1, s[3], 0);
 746              s[0] = s[1] = s[2] = s[3] = NULL;
 747              if ((i > 0) && (j > 0))
 748                s[0] = st->slices2[num - 1 - st->slices_h];
 749              if ((i < st->slices_w) && (j > 0))
 750                s[1] = st->slices2[num - 1];
 751              if ((i > 0) && (j < st->slices_h))
 752                s[2] = st->slices2[num - st->slices_h];
 753              if ((i < st->slices_w) && (j < st->slices_h))
 754                 s[3] = st->slices2[num];
 755              if (st->dir == 0)
 756                 _slice_obj_vert_color_merge(s[0], 3, s[1], 2, s[2], 0, s[3], 1);
 757              else if (st->dir == 1)
 758                 _slice_obj_vert_color_merge(s[0], 2, s[1], 3, s[2], 1, s[3], 0);
 759              else if (st->dir == 2)
 760                 _slice_obj_vert_color_merge(s[0], 2, s[1], 3, s[2], 1, s[3], 0);
 761              else/* if (st->dir == 3) will be this anyway */
 762                 _slice_obj_vert_color_merge(s[0], 3, s[1], 2, s[2], 0, s[3], 1);
 763              num++;
 764           }
 765      }
 766
 767    num = 0;
 768    for (i = 0; i < st->slices_w; i++)
 769      {
 770         for (j = 0; j < st->slices_h; j++)
 771           {
 772              _slice_3d(st, st->slices[num], ox, oy, ow, oh);
 773              _slice_3d(st, st->slices2[num], ox, oy, ow, oh);
 774              num++;
 775           }
 776      }
 777
 778    return 1;
 779 }
 780
 781 static void
 782 _state_end(Widget_Data *st)
 783 {
 784    _state_slices_clear(st);
 785 }
 786
 787
 788 static void
 789 flip_show_hide(Evas_Object *obj)
 790 {
 791    Widget_Data *wd = elm_widget_data_get(obj);
 792    if (elm_flip_front_visible_get(obj))
 793      {
 794         if (wd->pageflip)
 795           {
 796              if (wd->front.content)
 797                {
 798                   evas_object_move(wd->front.content, 4999, 4999);
 799                   evas_object_show(wd->front.clip);
 800                }
 801              else
 802                 evas_object_hide(wd->front.clip);
 803              if (wd->back.content)
 804                 evas_object_show(wd->back.clip);
 805              else
 806                 evas_object_hide(wd->back.clip);
 807           }
 808         else
 809           {
 810              if (wd->front.content)
 811                 evas_object_show(wd->front.clip);
 812              else
 813                 evas_object_hide(wd->front.clip);
 814              if (wd->back.content)
 815                 evas_object_hide(wd->back.clip);
 816              else
 817                 evas_object_hide(wd->back.clip);
 818           }
 819      }
 820    else
 821      {
 822         if (wd->pageflip)
 823           {
 824              if (wd->front.content)
 825                 evas_object_show(wd->front.clip);
 826              else
 827                 evas_object_hide(wd->front.clip);
 828              if (wd->back.content)
 829                {
 830                   evas_object_move(wd->back.content, 4999, 4999);
 831                   evas_object_show(wd->back.clip);
 832                }
 833              else
 834                 evas_object_hide(wd->back.clip);
 835           }
 836         else
 837           {
 838              if (wd->front.content)
 839                 evas_object_hide(wd->front.clip);
 840              else
 841                 evas_object_hide(wd->front.clip);
 842              if (wd->back.content)
 843                 evas_object_show(wd->back.clip);
 844              else
 845                 evas_object_hide(wd->back.clip);
 846           }
 847      }
 848 }
 849
 850 static void
 851 _flip_do(Evas_Object *obj, double t, Elm_Flip_Mode mode, int lin, int rev)
 852 {
 853    Evas_Coord x, y, w, h;
 854    double p, deg, pp;
 855    Evas_Map *mf, *mb;
 856    Evas_Coord cx, cy, px, py, foc;
 857    int lx, ly, lz, lr, lg, lb, lar, lag, lab;
 858    Widget_Data *wd = elm_widget_data_get(obj);
 859
 860    if (!wd) return;
 861
 862    mf = evas_map_new(4);
 863    evas_map_smooth_set(mf, EINA_FALSE);
 864    mb = evas_map_new(4);
 865    evas_map_smooth_set(mb, EINA_FALSE);
 866
 867    if (wd->front.content)
 868      {
 869         const char *type = evas_object_type_get(wd->front.content);
 870
 871         // FIXME: only handles filled obj
 872         if ((type) && (!strcmp(type, "image")))
 873           {
 874              int iw, ih;
 875              evas_object_image_size_get(wd->front.content, &iw, &ih);
 876              evas_object_geometry_get(wd->front.content, &x, &y, &w, &h);
 877              evas_map_util_points_populate_from_geometry(mf, x, y, w, h, 0);
 878              evas_map_point_image_uv_set(mf, 0, 0, 0);
 879              evas_map_point_image_uv_set(mf, 1, iw, 0);
 880              evas_map_point_image_uv_set(mf, 2, iw, ih);
 881              evas_map_point_image_uv_set(mf, 3, 0, ih);
 882           }
 883         else
 884           {
 885              evas_object_geometry_get(wd->front.content, &x, &y, &w, &h);
 886              evas_map_util_points_populate_from_geometry(mf, x, y, w, h, 0);
 887           }
 888      }
 889    if (wd->back.content)
 890      {
 891         const char *type = evas_object_type_get(wd->back.content);
 892
 893         if ((type) && (!strcmp(type, "image")))
 894           {
 895              int iw, ih;
 896              evas_object_image_size_get(wd->back.content, &iw, &ih);
 897              evas_object_geometry_get(wd->back.content, &x, &y, &w, &h);
 898              evas_map_util_points_populate_from_geometry(mb, x, y, w, h, 0);
 899              evas_map_point_image_uv_set(mb, 0, 0, 0);
 900              evas_map_point_image_uv_set(mb, 1, iw, 0);
 901              evas_map_point_image_uv_set(mb, 2, iw, ih);
 902              evas_map_point_image_uv_set(mb, 3, 0, ih);
 903           }
 904         else
 905           {
 906              evas_object_geometry_get(wd->back.content, &x, &y, &w, &h);
 907              evas_map_util_points_populate_from_geometry(mb, x, y, w, h, 0);
 908           }
 909      }
 910
 911    evas_object_geometry_get(obj, &x, &y, &w, &h);
 912
 913    cx = x + (w / 2);
 914    cy = y + (h / 2);
 915
 916    px = x + (w / 2);
 917    py = y + (h / 2);
 918    foc = 2048;
 919
 920    lx = cx;
 921    ly = cy;
 922    lz = -10000;
 923    lr = 255;
 924    lg = 255;
 925    lb = 255;
 926    lar = 0;
 927    lag = 0;
 928    lab = 0;
 929
 930    switch (mode)
 931      {
 932       case ELM_FLIP_ROTATE_Y_CENTER_AXIS:
 933          p = 1.0 - t;
 934          pp = p;
 935          if (!lin) pp = (p * p);
 936          p = 1.0 - pp;
 937          if (wd->state) deg = 180.0 * p;
 938          else deg = 180 + (180.0 * p);
 939          if (rev) deg = -deg;
 940          evas_map_util_3d_rotate(mf, 0.0, deg, 0.0, cx, cy, 0);
 941          evas_map_util_3d_rotate(mb, 0.0, 180 + deg, 0.0, cx, cy, 0);
 942          break;
 943       case ELM_FLIP_ROTATE_X_CENTER_AXIS:
 944          p = 1.0 - t;
 945          pp = p;
 946          if (!lin) pp = (p * p);
 947          p = 1.0 - pp;
 948          if (wd->state) deg = 180.0 * p;
 949          else deg = 180 + (180.0 * p);
 950          if (rev) deg = -deg;
 951          evas_map_util_3d_rotate(mf, deg, 0.0, 0.0, cx, cy, 0);
 952          evas_map_util_3d_rotate(mb, 180.0 + deg, 0.0, 0.0, cx, cy, 0);
 953          break;
 954       case ELM_FLIP_ROTATE_XZ_CENTER_AXIS:
 955          p = 1.0 - t;
 956          pp = p;
 957          if (!lin) pp = (p * p);
 958          p = 1.0 - pp;
 959          if (wd->state) deg = 180.0 * p;
 960          else deg = 180 + (180.0 * p);
 961          if (rev) deg = -deg;
 962          evas_map_util_3d_rotate(mf, deg, 0.0, deg, cx, cy, 0);
 963          evas_map_util_3d_rotate(mb, 180 + deg, 0.0, 180 + deg, cx, cy, 0);
 964          break;
 965       case ELM_FLIP_ROTATE_YZ_CENTER_AXIS:
 966          p = 1.0 - t;
 967          pp = p;
 968          if (!lin) pp = (p * p);
 969          p = 1.0 - pp;
 970          if (wd->state) deg = 180.0 * p;
 971          else deg = 180 + (180.0 * p);
 972          if (rev) deg = -deg;
 973          evas_map_util_3d_rotate(mf, 0.0, deg, deg, cx, cy, 0);
 974          evas_map_util_3d_rotate(mb, 0.0, 180.0 + deg, 180.0 + deg, cx, cy, 0);
 975          break;
 976       case ELM_FLIP_CUBE_LEFT:
 977          p = 1.0 - t;
 978          pp = p;
 979          if (!lin) pp = (p * p);
 980          p = 1.0 - pp;
 981          deg = -90.0 * p;
 982          if (wd->state)
 983            {
 984               evas_map_util_3d_rotate(mf, 0.0, deg, 0.0, cx, cy, w / 2);
 985               evas_map_util_3d_rotate(mb, 0.0, deg + 90, 0.0, cx, cy, w / 2);
 986            }
 987          else
 988            {
 989               evas_map_util_3d_rotate(mf, 0.0, deg + 90, 0.0, cx, cy, w / 2);
 990               evas_map_util_3d_rotate(mb, 0.0, deg, 0.0, cx, cy, w / 2);
 991            }
 992          break;
 993       case ELM_FLIP_CUBE_RIGHT:
 994          p = 1.0 - t;
 995          pp = p;
 996          if (!lin) pp = (p * p);
 997          p = 1.0 - pp;
 998          deg = 90.0 * p;
 999          if (wd->state)
1000            {
1001               evas_map_util_3d_rotate(mf, 0.0, deg, 0.0, cx, cy, w / 2);
1002               evas_map_util_3d_rotate(mb, 0.0, deg - 90, 0.0, cx, cy, w / 2);
1003            }
1004          else
1005            {
1006               evas_map_util_3d_rotate(mf, 0.0, deg - 90, 0.0, cx, cy, w / 2);
1007               evas_map_util_3d_rotate(mb, 0.0, deg, 0.0, cx, cy, w / 2);
1008            }
1009          break;
1010       case ELM_FLIP_CUBE_UP:
1011          p = 1.0 - t;
1012          pp = p;
1013          if (!lin) pp = (p * p);
1014          p = 1.0 - pp;
1015          deg = -90.0 * p;
1016          if (wd->state)
1017            {
1018               evas_map_util_3d_rotate(mf, deg, 0.0, 0.0, cx, cy, h / 2);
1019               evas_map_util_3d_rotate(mb, deg + 90, 0.0, 0.0, cx, cy, h / 2);
1020            }
1021          else
1022            {
1023               evas_map_util_3d_rotate(mf, deg + 90, 0.0, 0.0, cx, cy, h / 2);
1024               evas_map_util_3d_rotate(mb, deg, 0.0, 0.0, cx, cy, h / 2);
1025            }
1026          break;
1027       case ELM_FLIP_CUBE_DOWN:
1028          p = 1.0 - t;
1029          pp = p;
1030          if (!lin) pp = (p * p);
1031          p = 1.0 - pp;
1032          deg = 90.0 * p;
1033          if (wd->state)
1034            {
1035               evas_map_util_3d_rotate(mf, deg, 0.0, 0.0, cx, cy, h / 2);
1036               evas_map_util_3d_rotate(mb, deg - 90, 0.0, 0.0, cx, cy, h / 2);
1037            }
1038          else
1039            {
1040               evas_map_util_3d_rotate(mf, deg - 90, 0.0, 0.0, cx, cy, h / 2);
1041               evas_map_util_3d_rotate(mb, deg, 0.0, 0.0, cx, cy, h / 2);
1042            }
1043          break;
1044       case ELM_FLIP_PAGE_LEFT:
1045         break;
1046       case ELM_FLIP_PAGE_RIGHT:
1047         break;
1048       case ELM_FLIP_PAGE_UP:
1049         break;
1050       case ELM_FLIP_PAGE_DOWN:
1051         break;
1052       default:
1053          break;
1054      }
1055
1056
1057    if (wd->front.content)
1058      {
1059         evas_map_util_3d_lighting(mf, lx, ly, lz, lr, lg, lb, lar, lag, lab);
1060         evas_map_util_3d_perspective(mf, px, py, 0, foc);
1061         evas_object_map_set(wd->front.content, mf);
1062         evas_object_map_enable_set(wd->front.content, 1);
1063         if (evas_map_util_clockwise_get(mf)) evas_object_show(wd->front.clip);
1064         else evas_object_hide(wd->front.clip);
1065      }
1066
1067    if (wd->back.content)
1068      {
1069         evas_map_util_3d_lighting(mb, lx, ly, lz, lr, lg, lb, lar, lag, lab);
1070         evas_map_util_3d_perspective(mb, px, py, 0, foc);
1071         evas_object_map_set(wd->back.content, mb);
1072         evas_object_map_enable_set(wd->back.content, 1);
1073         if (evas_map_util_clockwise_get(mb)) evas_object_show(wd->back.clip);
1074         else evas_object_hide(wd->back.clip);
1075      }
1076
1077    evas_map_free(mf);
1078    evas_map_free(mb);
1079 }
1080
1081 static void
1082 _showhide(Evas_Object *obj)
1083 {
1084    Widget_Data *wd = elm_widget_data_get(obj);
1085    Evas_Coord x, y, w, h;
1086    if (!wd) return;
1087
1088    evas_object_geometry_get(obj, &x, &y, &w, &h);
1089    if (wd->front.content)
1090      {
1091         if ((wd->pageflip) && (wd->state))
1092           {
1093              evas_object_move(wd->front.content, 4999, 4999);
1094           }
1095         else
1096           {
1097              if (!wd->animator)
1098                 evas_object_move(wd->front.content, x, y);
1099           }
1100         evas_object_resize(wd->front.content, w, h);
1101      }
1102    if (wd->back.content)
1103      {
1104         if ((wd->pageflip) && (!wd->state))
1105           {
1106              evas_object_move(wd->back.content, 4999, 4999);
1107           }
1108         else
1109           {
1110              if (!wd->animator)
1111                 evas_object_move(wd->back.content, x, y);
1112           }
1113         evas_object_resize(wd->back.content, w, h);
1114      }
1115
1116 }
1117
1118 static Eina_Bool
1119 _flip(Evas_Object *obj)
1120 {
1121    Widget_Data *wd = elm_widget_data_get(obj);
1122    double t = ecore_loop_time_get() - wd->start;
1123    Evas_Coord w, h;
1124
1125    if (!wd) return ECORE_CALLBACK_CANCEL;
1126    if (!wd->animator) return ECORE_CALLBACK_CANCEL;
1127
1128    t = t / wd->len;
1129    if (t > 1.0) t = 1.0;
1130
1131    evas_object_geometry_get(obj, NULL, NULL, &w, &h);
1132    if (wd->mode == ELM_FLIP_PAGE_LEFT)
1133      {
1134         wd->dir = 0;
1135         wd->started = EINA_TRUE;
1136         wd->pageflip = EINA_TRUE;
1137         wd->down_x = w - 1;
1138         wd->down_y = h / 2;
1139         wd->x = (1.0 - t) * wd->down_x;
1140         wd->y = wd->down_y;
1141         flip_show_hide(obj);
1142         _state_update(wd);
1143      }
1144    else if (wd->mode == ELM_FLIP_PAGE_RIGHT)
1145      {
1146         wd->dir = 1;
1147         wd->started = EINA_TRUE;
1148         wd->pageflip = EINA_TRUE;
1149         wd->down_x = 0;
1150         wd->down_y = h / 2;
1151         wd->x = (t) * w;
1152         wd->y = wd->down_y;
1153         flip_show_hide(obj);
1154         _state_update(wd);
1155      }
1156    else if (wd->mode == ELM_FLIP_PAGE_UP)
1157      {
1158         wd->dir = 2;
1159         wd->started = EINA_TRUE;
1160         wd->pageflip = EINA_TRUE;
1161         wd->down_x = w / 2;
1162         wd->down_y = h - 1;
1163         wd->x = wd->down_x;
1164         wd->y = (1.0 - t) * wd->down_y;
1165         flip_show_hide(obj);
1166         _state_update(wd);
1167      }
1168    else if (wd->mode == ELM_FLIP_PAGE_DOWN)
1169      {
1170         wd->dir = 3;
1171         wd->started = EINA_TRUE;
1172         wd->pageflip = EINA_TRUE;
1173         wd->down_x = w / 2;
1174         wd->down_y = 0;
1175         wd->x = wd->down_x;
1176         wd->y = (t) * h;
1177         flip_show_hide(obj);
1178         _state_update(wd);
1179      }
1180    else
1181       _flip_do(obj, t, wd->mode, 0, 0);
1182
1183    if (t >= 1.0)
1184      {
1185         wd->pageflip = EINA_FALSE;
1186         _state_end(wd);
1187         evas_object_map_enable_set(wd->front.content, 0);
1188         evas_object_map_enable_set(wd->back.content, 0);
1189         // FIXME: hack around evas rendering bug (only fix makes evas bitch-slow
1190         evas_object_resize(wd->front.content, 0, 0);
1191         evas_object_resize(wd->back.content, 0, 0);
1192         evas_smart_objects_calculate(evas_object_evas_get(obj));
1193         // FIXME: end hack
1194         wd->animator = NULL;
1195         wd->state = !wd->state;
1196         _configure(obj);
1197         flip_show_hide(obj);
1198         evas_object_smart_callback_call(obj, SIG_ANIMATE_DONE, NULL);
1199         return ECORE_CALLBACK_CANCEL;
1200      }
1201    return ECORE_CALLBACK_RENEW;
1202 }
1203
1204 static void
1205 _configure(Evas_Object *obj)
1206 {
1207    Widget_Data *wd = elm_widget_data_get(obj);
1208    Evas_Coord x, y, w, h;
1209    Evas_Coord fsize;
1210    if (!wd) return;
1211
1212    _showhide(obj);
1213    evas_object_geometry_get(obj, &x, &y, &w, &h);
1214    // FIXME: manual flip wont get fixed
1215    if (wd->animator) _flip(obj);
1216
1217    if (wd->event[0])
1218      {
1219         fsize = (double)w * wd->dir_hitsize[0];
1220         elm_coords_finger_size_adjust(0, NULL, 1, &fsize);
1221         evas_object_move(wd->event[0], x, y);
1222         evas_object_resize(wd->event[0], w, fsize);
1223      }
1224    if (wd->event[1])
1225      {
1226         fsize = (double)w * wd->dir_hitsize[1];
1227         elm_coords_finger_size_adjust(0, NULL, 1, &fsize);
1228         evas_object_move(wd->event[1], x, y + h - fsize);
1229         evas_object_resize(wd->event[1], w, fsize);
1230      }
1231    if (wd->event[2])
1232      {
1233         fsize = (double)h * wd->dir_hitsize[2];
1234         elm_coords_finger_size_adjust(1, &fsize, 0, NULL);
1235         evas_object_move(wd->event[2], x, y);
1236         evas_object_resize(wd->event[2], fsize, h);
1237      }
1238    if (wd->event[3])
1239      {
1240         fsize = (double)h * wd->dir_hitsize[3];
1241         elm_coords_finger_size_adjust(1, &fsize, 0, NULL);
1242         evas_object_move(wd->event[3], x + w - fsize, y);
1243         evas_object_resize(wd->event[3], fsize, h);
1244      }
1245 }
1246
1247 static void
1248 _move(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1249 {
1250    _configure(obj);
1251 }
1252
1253 static void
1254 _resize(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1255 {
1256    _configure(obj);
1257 }
1258
1259 static Eina_Bool
1260 _animate(void *data)
1261 {
1262    return _flip(data);
1263 }
1264
1265 static double
1266 _pos_get(Widget_Data *wd, int *rev, Elm_Flip_Mode *m)
1267 {
1268    Evas_Coord x, y, w, h;
1269    double t = 1.0;
1270
1271    evas_object_geometry_get(wd->obj, &x, &y, &w, &h);
1272    switch (wd->intmode)
1273      {
1274       case ELM_FLIP_INTERACTION_ROTATE:
1275       case ELM_FLIP_INTERACTION_CUBE:
1276           {
1277              if (wd->dir == 0)
1278                {
1279                   if (wd->down_x > 0)
1280                     t = 1.0 - ((double)wd->x / (double)wd->down_x);
1281                   *rev = 1;
1282                }
1283              else if (wd->dir == 1)
1284                {
1285                   if (wd->down_x < w)
1286                     t = 1.0 - ((double)(w - wd->x) / (double)(w - wd->down_x));
1287                }
1288              else if (wd->dir == 2)
1289                {
1290                   if (wd->down_y > 0)
1291                     t = 1.0 - ((double)wd->y / (double)wd->down_y);
1292                }
1293              else if (wd->dir == 3)
1294                {
1295                   if (wd->down_y < h)
1296                     t = 1.0 - ((double)(h - wd->y) / (double)(h - wd->down_y));
1297                   *rev = 1;
1298                }
1299
1300              if (t < 0.0) t = 0.0;
1301              else if (t > 1.0) t = 1.0;
1302
1303              if ((wd->dir == 0) || (wd->dir == 1))
1304                {
1305                   if (wd->intmode == ELM_FLIP_INTERACTION_ROTATE)
1306                      *m = ELM_FLIP_ROTATE_Y_CENTER_AXIS;
1307                   else if (wd->intmode == ELM_FLIP_INTERACTION_CUBE)
1308                     {
1309                        if (*rev)
1310                           *m = ELM_FLIP_CUBE_LEFT;
1311                        else
1312                           *m = ELM_FLIP_CUBE_RIGHT;
1313                     }
1314                }
1315              else
1316                {
1317                   if (wd->intmode == ELM_FLIP_INTERACTION_ROTATE)
1318                      *m = ELM_FLIP_ROTATE_X_CENTER_AXIS;
1319                   else if (wd->intmode == ELM_FLIP_INTERACTION_CUBE)
1320                     {
1321                        if (*rev)
1322                           *m = ELM_FLIP_CUBE_UP;
1323                        else
1324                           *m = ELM_FLIP_CUBE_DOWN;
1325                     }
1326                }
1327           }
1328       default:
1329         break;
1330      }
1331    return t;
1332 }
1333
1334 static Eina_Bool
1335 _event_anim(void *data, double pos)
1336 {
1337    Widget_Data *wd = data;
1338    double p;
1339
1340    p = ecore_animator_pos_map(pos, ECORE_POS_MAP_ACCELERATE, 0.0, 0.0);
1341    if (wd->finish)
1342      {
1343         if (wd->dir == 0)
1344            wd->x = wd->ox * (1.0 - p);
1345         else if (wd->dir == 1)
1346            wd->x = wd->ox + ((wd->w - wd->ox) * p);
1347         else if (wd->dir == 2)
1348            wd->y = wd->oy * (1.0 - p);
1349         else if (wd->dir == 3)
1350            wd->y = wd->oy + ((wd->h - wd->oy) * p);
1351      }
1352    else
1353      {
1354         if (wd->dir == 0)
1355            wd->x = wd->ox + ((wd->w - wd->ox) * p);
1356         else if (wd->dir == 1)
1357            wd->x = wd->ox * (1.0 - p);
1358         else if (wd->dir == 2)
1359            wd->y = wd->oy + ((wd->h - wd->oy) * p);
1360         else if (wd->dir == 3)
1361            wd->y = wd->oy * (1.0 - p);
1362      }
1363    switch (wd->intmode)
1364      {
1365       case ELM_FLIP_INTERACTION_NONE:
1366         break;
1367       case ELM_FLIP_INTERACTION_ROTATE:
1368       case ELM_FLIP_INTERACTION_CUBE:
1369           {
1370              Elm_Flip_Mode m = ELM_FLIP_ROTATE_X_CENTER_AXIS;
1371              int rev = 0;
1372              p = _pos_get(wd, &rev, &m);
1373              _flip_do(wd->obj, p, m, 1, rev);
1374           }
1375         break;
1376       case ELM_FLIP_INTERACTION_PAGE:
1377         wd->pageflip = EINA_TRUE;
1378         _configure(data);
1379         _state_update(wd);
1380         break;
1381       default:
1382         break;
1383      }
1384    if (pos < 1.0) return ECORE_CALLBACK_RENEW;
1385
1386    wd->pageflip = EINA_FALSE;
1387    _state_end(wd);
1388    evas_object_map_enable_set(wd->front.content, 0);
1389    evas_object_map_enable_set(wd->back.content, 0);
1390    // FIXME: hack around evas rendering bug (only fix makes evas bitch-slow
1391    evas_object_resize(wd->front.content, 0, 0);
1392    evas_object_resize(wd->back.content, 0, 0);
1393    evas_smart_objects_calculate(evas_object_evas_get(wd->obj));
1394    // FIXME: end hack
1395    wd->animator = NULL;
1396    if (wd->finish) wd->state = !wd->state;
1397    flip_show_hide(wd->obj);
1398    _configure(wd->obj);
1399    wd->animator = NULL;
1400    evas_object_smart_callback_call(wd->obj, SIG_ANIMATE_DONE, NULL);
1401
1402    return ECORE_CALLBACK_CANCEL;
1403 }
1404
1405 static void
1406 _update_job(void *data)
1407 {
1408    Widget_Data *wd = data;
1409    double p;
1410    Elm_Flip_Mode m = ELM_FLIP_ROTATE_X_CENTER_AXIS;
1411    int rev = 0;
1412
1413    wd->job = NULL;
1414    switch (wd->intmode)
1415      {
1416       case ELM_FLIP_INTERACTION_ROTATE:
1417       case ELM_FLIP_INTERACTION_CUBE:
1418         p = _pos_get(wd, &rev, &m);
1419         _flip_do(wd->obj, p, m, 1, rev);
1420         break;
1421       case ELM_FLIP_INTERACTION_PAGE:
1422         wd->pageflip = EINA_TRUE;
1423         _configure(data);
1424         _state_update(wd);
1425         break;
1426       default:
1427         break;
1428      }
1429 }
1430
1431 static void
1432 _down_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1433 {
1434    Evas_Object *fl = data;
1435    Widget_Data *wd = elm_widget_data_get(fl);
1436    Evas_Event_Mouse_Down *ev = event_info;
1437    Evas_Coord x, y, w, h;
1438
1439    if (!wd) return;
1440    if (ev->button != 1) return;
1441    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return ;
1442    if (wd->animator)
1443      {
1444         ecore_animator_del(wd->animator);
1445         wd->animator = NULL;
1446      }
1447    wd->down = EINA_TRUE;
1448    wd->started = EINA_FALSE;
1449    evas_object_geometry_get(data, &x, &y, &w, &h);
1450    wd->x = ev->canvas.x - x;
1451    wd->y = ev->canvas.y - y;
1452    wd->w = w;
1453    wd->h = h;
1454    wd->down_x = wd->x;
1455    wd->down_y = wd->y;
1456 }
1457
1458 static void
1459 _up_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1460 {
1461    Evas_Object *fl = data;
1462    Widget_Data *wd = elm_widget_data_get(fl);
1463    Evas_Event_Mouse_Up *ev = event_info;
1464    Evas_Coord x, y, w, h;
1465    double tm = 0.5;
1466
1467    if (!wd) return;
1468    if (ev->button != 1) return;
1469    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return ;
1470    wd->down = 0;
1471    evas_object_geometry_get(data, &x, &y, &w, &h);
1472    wd->x = ev->canvas.x - x;
1473    wd->y = ev->canvas.y - y;
1474    wd->w = w;
1475    wd->h = h;
1476    wd->ox = wd->x;
1477    wd->oy = wd->y;
1478    if (wd->job)
1479      {
1480         ecore_job_del(wd->job);
1481         wd->job = NULL;
1482      }
1483    wd->finish = EINA_FALSE;
1484    if (wd->dir == 0)
1485      {
1486         tm = (double)wd->x / (double)wd->w;
1487         if (wd->x < (wd->w / 2)) wd->finish = EINA_TRUE;
1488      }
1489    else if (wd->dir == 1)
1490      {
1491         if (wd->x > (wd->w / 2)) wd->finish = EINA_TRUE;
1492         tm = 1.0 - ((double)wd->x / (double)wd->w);
1493      }
1494    else if (wd->dir == 2)
1495      {
1496         if (wd->y < (wd->h / 2)) wd->finish = EINA_TRUE;
1497         tm = (double)wd->y / (double)wd->h;
1498      }
1499    else if (wd->dir == 3)
1500      {
1501         if (wd->y > (wd->h / 2)) wd->finish = EINA_TRUE;
1502         tm = 1.0 - ((double)wd->y / (double)wd->h);
1503      }
1504    if (tm < 0.01) tm = 0.01;
1505    else if (tm > 0.99) tm = 0.99;
1506    if (!wd->finish) tm = 1.0 - tm;
1507    tm *= 1.0; // FIXME: config for anim time
1508    if (wd->animator) ecore_animator_del(wd->animator);
1509    wd->animator = ecore_animator_timeline_add(tm, _event_anim, wd);
1510    _event_anim(wd, 0.0);
1511 }
1512
1513 static void
1514 _move_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1515 {
1516    Evas_Object *fl = data;
1517    Widget_Data *wd = elm_widget_data_get(fl);
1518    Evas_Event_Mouse_Move *ev = event_info;
1519    Evas_Coord x, y, w, h;
1520
1521    if (!wd) return;
1522    if (!wd->down) return;
1523    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return ;
1524    evas_object_geometry_get(data, &x, &y, &w, &h);
1525    wd->x = ev->cur.canvas.x - x;
1526    wd->y = ev->cur.canvas.y - y;
1527    wd->w = w;
1528    wd->h = h;
1529    if (!wd->started)
1530      {
1531         Evas_Coord dx, dy;
1532
1533         dx = wd->x - wd->down_x;
1534         dy = wd->y - wd->down_y;
1535         if (((dx * dx) + (dy * dy)) >
1536             (_elm_config->finger_size * _elm_config->finger_size / 4))
1537           {
1538              wd->dir = 0;
1539              if ((wd->x > (w / 2)) &&
1540                  (dx <  0) && (abs(dx) > abs(dy)))
1541                wd->dir = 0; // left
1542              else if ((wd->x < (w / 2)) && (dx >= 0) &&
1543                       (abs(dx) > abs(dy)))
1544                wd->dir = 1; // right
1545              else if ((wd->y > (h / 2)) && (dy <  0) && (abs(dy) >= abs(dx)))
1546                wd->dir = 2; // up
1547              else if ((wd->y < (h / 2)) && (dy >= 0) && (abs(dy) >= abs(dx)))
1548                wd->dir = 3; // down
1549              wd->started = EINA_TRUE;
1550              if (wd->intmode == ELM_FLIP_INTERACTION_PAGE)
1551                wd->pageflip = EINA_TRUE;
1552              flip_show_hide(data);
1553              evas_smart_objects_calculate(evas_object_evas_get(data));
1554              _flip(data);
1555              // FIXME: hack around evas rendering bug (only fix makes evas bitch-slow)
1556              evas_object_map_enable_set(wd->front.content, EINA_FALSE);
1557              evas_object_map_enable_set(wd->back.content, EINA_FALSE);
1558 // FIXME: XXX why does this bork interactive flip??
1559 //             evas_object_resize(wd->front.content, 0, 0);
1560 //             evas_object_resize(wd->back.content, 0, 0);
1561              evas_smart_objects_calculate(evas_object_evas_get(data));
1562              _configure(obj);
1563              // FIXME: end hack
1564              evas_object_smart_callback_call(obj, SIG_ANIMATE_BEGIN, NULL);
1565           }
1566         else return;
1567      }
1568    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
1569    if (wd->job) ecore_job_del(wd->job);
1570    wd->job = ecore_job_add(_update_job, wd);
1571 }
1572
1573 static void
1574 _flip_content_front_set(Evas_Object *obj, Evas_Object *content)
1575 {
1576    Widget_Data *wd = elm_widget_data_get(obj);
1577    if (!wd) return;
1578
1579    int i;
1580
1581    if (wd->front.content == content) return;
1582    if (wd->front.content) evas_object_del(wd->front.content);
1583    wd->front.content = content;
1584    if (content)
1585      {
1586         elm_widget_sub_object_add(obj, content);
1587         evas_object_smart_member_add(content, obj);
1588         evas_object_clip_set(content, wd->front.clip);
1589         evas_object_event_callback_add(content,
1590                                        EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1591                                        _changed_size_hints, obj);
1592         _sizing_eval(obj);
1593      }
1594
1595    // force calc to contents are the right size before transition
1596    evas_smart_objects_calculate(evas_object_evas_get(obj));
1597    flip_show_hide(obj);
1598    _configure(obj);
1599    if (wd->intmode != ELM_FLIP_INTERACTION_NONE)
1600      {
1601         for (i = 0; i < 4; i++) evas_object_raise(wd->event[i]);
1602      }
1603 }
1604
1605 static void
1606 _flip_content_back_set(Evas_Object *obj, Evas_Object *content)
1607 {
1608    Widget_Data *wd = elm_widget_data_get(obj);
1609    if (!wd) return;
1610
1611    int i;
1612    if (wd->back.content == content) return;
1613    if (wd->back.content) evas_object_del(wd->back.content);
1614    wd->back.content = content;
1615    if (content)
1616      {
1617         elm_widget_sub_object_add(obj, content);
1618         evas_object_smart_member_add(content, obj);
1619         evas_object_clip_set(content, wd->back.clip);
1620         evas_object_event_callback_add(content,
1621                                        EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1622                                        _changed_size_hints, obj);
1623         _sizing_eval(obj);
1624      }
1625
1626    // force calc to contents are the right size before transition
1627    evas_smart_objects_calculate(evas_object_evas_get(obj));
1628    flip_show_hide(obj);
1629    _configure(obj);
1630    if (wd->intmode != ELM_FLIP_INTERACTION_NONE)
1631      {
1632         for (i = 0; i < 4; i++) evas_object_raise(wd->event[i]);
1633      }
1634 }
1635
1636 static Evas_Object *
1637 _content_front_unset(Evas_Object *obj)
1638 {
1639    Widget_Data *wd = elm_widget_data_get(obj);
1640    if ((!wd) || (!wd->front.content)) return NULL;
1641
1642    Evas_Object *content = wd->front.content;
1643    evas_object_clip_unset(content);
1644    elm_widget_sub_object_del(obj, content);
1645    evas_object_event_callback_del_full(content,
1646                                        EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1647                                        _changed_size_hints, obj);
1648    evas_object_smart_member_del(content);
1649    wd->front.content = NULL;
1650    return content;
1651 }
1652
1653 static Evas_Object *
1654 _content_back_unset(Evas_Object *obj)
1655 {
1656    Widget_Data *wd = elm_widget_data_get(obj);
1657    if ((!wd) || (!wd->back.content)) return NULL;
1658
1659    Evas_Object *content = wd->back.content;
1660    evas_object_clip_unset(content);
1661    elm_widget_sub_object_del(obj, content);
1662    evas_object_event_callback_del_full(content,
1663                                        EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1664                                        _changed_size_hints, obj);
1665    evas_object_smart_member_del(content);
1666    wd->back.content = NULL;
1667    return content;
1668 }
1669
1670 static void
1671 _content_set_hook(Evas_Object *obj, const char *part, Evas_Object *content)
1672 {
1673    ELM_CHECK_WIDTYPE(obj, widtype);
1674
1675    if (!part || !strcmp(part, "front"))
1676      _flip_content_front_set(obj, content);
1677    else if (!strcmp(part, "back"))
1678      _flip_content_back_set(obj, content);
1679 }
1680
1681 static Evas_Object *
1682 _content_get_hook(const Evas_Object *obj, const char *part)
1683 {
1684    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1685    Widget_Data *wd = elm_widget_data_get(obj);
1686    if (!wd) return NULL;
1687
1688    if (!part || !strcmp(part, "front"))
1689      return wd->front.content;
1690    else if (!strcmp(part, "back"))
1691      return wd->back.content;
1692
1693    return NULL;
1694 }
1695
1696 static Evas_Object *
1697 _content_unset_hook(Evas_Object *obj, const char *part)
1698 {
1699    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1700
1701    if (!part || !strcmp(part, "front"))
1702      return _content_front_unset(obj);
1703    else if (!strcmp(part, "back"))
1704      return _content_back_unset(obj);
1705
1706    return NULL;
1707 }
1708
1709 EAPI Evas_Object *
1710 elm_flip_add(Evas_Object *parent)
1711 {
1712    Evas_Object *obj;
1713    Evas *e;
1714    Widget_Data *wd;
1715
1716    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
1717
1718    ELM_SET_WIDTYPE(widtype, "flip");
1719    elm_widget_type_set(obj, "flip");
1720    elm_widget_sub_object_add(parent, obj);
1721    elm_widget_data_set(obj, wd);
1722    elm_widget_del_hook_set(obj, _del_hook);
1723    elm_widget_theme_hook_set(obj, _theme_hook);
1724    elm_widget_focus_next_hook_set(obj, _elm_flip_focus_next_hook);
1725    elm_widget_can_focus_set(obj, EINA_FALSE);
1726    elm_widget_content_set_hook_set(obj, _content_set_hook);
1727    elm_widget_content_get_hook_set(obj, _content_get_hook);
1728    elm_widget_content_unset_hook_set(obj, _content_unset_hook);
1729
1730    wd->obj = obj;
1731
1732    wd->clip = evas_object_rectangle_add(e);
1733    evas_object_static_clip_set(wd->clip, EINA_TRUE);
1734    evas_object_color_set(wd->clip, 255, 255, 255, 255);
1735    evas_object_move(wd->clip, -49999, -49999);
1736    evas_object_resize(wd->clip, 99999, 99999);
1737    elm_widget_sub_object_add(obj, wd->clip);
1738    evas_object_clip_set(wd->clip, evas_object_clip_get(obj));
1739    evas_object_smart_member_add(wd->clip, obj);
1740
1741    wd->front.clip = evas_object_rectangle_add(e);
1742    evas_object_static_clip_set(wd->front.clip, EINA_TRUE);
1743    evas_object_data_set(wd->front.clip, "_elm_leaveme", obj);
1744    evas_object_color_set(wd->front.clip, 255, 255, 255, 255);
1745    evas_object_move(wd->front.clip, -49999, -49999);
1746    evas_object_resize(wd->front.clip, 99999, 99999);
1747    elm_widget_sub_object_add(obj, wd->front.clip);
1748    evas_object_smart_member_add(wd->front.clip, obj);
1749    evas_object_clip_set(wd->front.clip, wd->clip);
1750
1751    wd->back.clip = evas_object_rectangle_add(e);
1752    evas_object_static_clip_set(wd->back.clip, EINA_TRUE);
1753    evas_object_data_set(wd->back.clip, "_elm_leaveme", obj);
1754    evas_object_color_set(wd->back.clip, 255, 255, 255, 255);
1755    evas_object_move(wd->back.clip, -49999, -49999);
1756    evas_object_resize(wd->back.clip, 99999, 99999);
1757    elm_widget_sub_object_add(wd->back.clip, obj);
1758    evas_object_smart_member_add(obj, wd->back.clip);
1759    evas_object_clip_set(wd->back.clip, wd->clip);
1760
1761    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, obj);
1762    evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE, _move, NULL);
1763    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _resize, NULL);
1764    evas_object_event_callback_add(obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1765                                        _changed_size_hints, obj);;
1766
1767    evas_object_smart_callbacks_descriptions_set(obj, _signals);
1768
1769    wd->state = EINA_TRUE;
1770    wd->intmode = ELM_FLIP_INTERACTION_NONE;
1771
1772    _sizing_eval(obj);
1773
1774    return obj;
1775 }
1776
1777 EAPI Eina_Bool
1778 elm_flip_front_visible_get(const Evas_Object *obj)
1779 {
1780    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1781    Widget_Data *wd = elm_widget_data_get(obj);
1782    if (!wd) return EINA_FALSE;
1783    return wd->state;
1784 }
1785
1786 EAPI void
1787 elm_flip_perspective_set(Evas_Object *obj, Evas_Coord foc __UNUSED__, Evas_Coord x __UNUSED__, Evas_Coord y __UNUSED__)
1788 {
1789    ELM_CHECK_WIDTYPE(obj, widtype);
1790    Widget_Data *wd = elm_widget_data_get(obj);
1791    if (!wd) return;
1792 }
1793
1794 // FIXME: add ambient and lighting control
1795
1796 EAPI void
1797 elm_flip_go(Evas_Object *obj, Elm_Flip_Mode mode)
1798 {
1799    ELM_CHECK_WIDTYPE(obj, widtype);
1800    Widget_Data *wd = elm_widget_data_get(obj);
1801    if (!wd) return;
1802    if (!wd->animator) wd->animator = ecore_animator_add(_animate, obj);
1803    flip_show_hide(obj);
1804    wd->mode = mode;
1805    wd->start = ecore_loop_time_get();
1806    wd->len = 0.5; // FIXME: make config val
1807    if ((wd->mode == ELM_FLIP_PAGE_LEFT) ||
1808        (wd->mode == ELM_FLIP_PAGE_RIGHT) ||
1809        (wd->mode == ELM_FLIP_PAGE_UP) ||
1810        (wd->mode == ELM_FLIP_PAGE_DOWN))
1811       wd->pageflip = EINA_TRUE;
1812    // force calc to contents are the right size before transition
1813    evas_smart_objects_calculate(evas_object_evas_get(obj));
1814    _flip(obj);
1815    // FIXME: hack around evas rendering bug (only fix makes evas bitch-slow)
1816    evas_object_map_enable_set(wd->front.content, 0);
1817    evas_object_map_enable_set(wd->back.content, 0);
1818    evas_object_resize(wd->front.content, 0, 0);
1819    evas_object_resize(wd->back.content, 0, 0);
1820    evas_smart_objects_calculate(evas_object_evas_get(obj));
1821    _configure(obj);
1822    // FIXME: end hack
1823    evas_object_smart_callback_call(obj, SIG_ANIMATE_BEGIN, NULL);
1824 }
1825
1826 EAPI void
1827 elm_flip_interaction_set(Evas_Object *obj, Elm_Flip_Interaction mode)
1828 {
1829    ELM_CHECK_WIDTYPE(obj, widtype);
1830    int i;
1831    Widget_Data *wd = elm_widget_data_get(obj);
1832    if (!wd) return;
1833    if (wd->intmode == mode) return;
1834    wd->intmode = mode;
1835    for (i = 0; i < 4; i++)
1836      {
1837         if (wd->intmode == ELM_FLIP_INTERACTION_NONE)
1838           {
1839              if (wd->event[i])
1840                {
1841                   evas_object_del(wd->event[i]);
1842                   wd->event[i] = NULL;
1843                }
1844           }
1845         else
1846           {
1847              if ((wd->dir_enabled[i]) && (!wd->event[i]))
1848                {
1849                   Evas *e = evas_object_evas_get(obj);
1850                   wd->event[i] = evas_object_rectangle_add(e);
1851                   elm_widget_sub_object_add(obj, wd->event[i]);
1852                   evas_object_clip_set(wd->event[i], evas_object_clip_get(obj));
1853                   evas_object_color_set(wd->event[i], 0, 0, 0, 0);
1854                   evas_object_show(wd->event[i]);
1855                   evas_object_smart_member_add(wd->event[i], obj);
1856                   evas_object_event_callback_add(wd->event[i],
1857                                                  EVAS_CALLBACK_MOUSE_DOWN,
1858                                                  _down_cb, obj);
1859                   evas_object_event_callback_add(wd->event[i],
1860                                                  EVAS_CALLBACK_MOUSE_UP,
1861                                                  _up_cb, obj);
1862                   evas_object_event_callback_add(wd->event[i],
1863                                                  EVAS_CALLBACK_MOUSE_MOVE,
1864                                                  _move_cb, obj);
1865                }
1866           }
1867      }
1868    _sizing_eval(obj);
1869    _configure(obj);
1870 }
1871
1872 EAPI Elm_Flip_Interaction
1873 elm_flip_interaction_get(const Evas_Object *obj)
1874 {
1875    ELM_CHECK_WIDTYPE(obj, widtype) ELM_FLIP_INTERACTION_NONE;
1876    Widget_Data *wd = elm_widget_data_get(obj);
1877    if (!wd) return ELM_FLIP_INTERACTION_NONE;
1878    return wd->intmode;
1879 }
1880
1881 EAPI void
1882 elm_flip_interaction_direction_enabled_set(Evas_Object *obj, Elm_Flip_Direction dir, Eina_Bool enabled)
1883 {
1884    ELM_CHECK_WIDTYPE(obj, widtype);
1885    Widget_Data *wd = elm_widget_data_get(obj);
1886    int i = -1;
1887    if (!wd) return;
1888    enabled = !!enabled;
1889    if (dir == ELM_FLIP_DIRECTION_UP)    i = 0;
1890    else if (dir == ELM_FLIP_DIRECTION_DOWN)  i = 1;
1891    else if (dir == ELM_FLIP_DIRECTION_LEFT)  i = 2;
1892    else if (dir == ELM_FLIP_DIRECTION_RIGHT) i = 3;
1893    if (i < 0) return;
1894    if (wd->dir_enabled[i] == enabled) return;
1895    wd->dir_enabled[i] = enabled;
1896    if (wd->intmode == ELM_FLIP_INTERACTION_NONE) return;
1897    if ((wd->dir_enabled[i]) && (!wd->event[i]))
1898      {
1899         wd->event[i] = evas_object_rectangle_add(evas_object_evas_get(obj));
1900         elm_widget_sub_object_add(obj, wd->event[i]);
1901         evas_object_clip_set(wd->event[i], evas_object_clip_get(obj));
1902         evas_object_color_set(wd->event[i], 0, 0, 0, 0);
1903         evas_object_show(wd->event[i]);
1904         evas_object_smart_member_add(wd->event[i], obj);
1905         evas_object_event_callback_add(wd->event[i], EVAS_CALLBACK_MOUSE_DOWN,
1906                                        _down_cb, obj);
1907         evas_object_event_callback_add(wd->event[i], EVAS_CALLBACK_MOUSE_UP,
1908                                        _up_cb, obj);
1909         evas_object_event_callback_add(wd->event[i], EVAS_CALLBACK_MOUSE_MOVE,
1910                                        _move_cb, obj);
1911      }
1912    else if (!(wd->dir_enabled[i]) && (wd->event[i]))
1913      {
1914         evas_object_del(wd->event[i]);
1915         wd->event[i] = NULL;
1916      }
1917    _sizing_eval(obj);
1918    _configure(obj);
1919 }
1920
1921 EAPI Eina_Bool
1922 elm_flip_interaction_direction_enabled_get(Evas_Object *obj, Elm_Flip_Direction dir)
1923 {
1924    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1925    Widget_Data *wd = elm_widget_data_get(obj);
1926    int i = -1;
1927    if (!wd) return EINA_FALSE;
1928    if (dir == ELM_FLIP_DIRECTION_UP) i = 0;
1929    else if (dir == ELM_FLIP_DIRECTION_DOWN) i = 1;
1930    else if (dir == ELM_FLIP_DIRECTION_LEFT) i = 2;
1931    else if (dir == ELM_FLIP_DIRECTION_RIGHT) i = 3;
1932    if (i < 0) return EINA_FALSE;
1933    return wd->dir_enabled[i];
1934 }
1935
1936 EAPI void
1937 elm_flip_interaction_direction_hitsize_set(Evas_Object *obj, Elm_Flip_Direction dir, double hitsize)
1938 {
1939    ELM_CHECK_WIDTYPE(obj, widtype);
1940    Widget_Data *wd = elm_widget_data_get(obj);
1941    int i = -1;
1942    if (!wd) return;
1943    if (dir == ELM_FLIP_DIRECTION_UP) i = 0;
1944    else if (dir == ELM_FLIP_DIRECTION_DOWN) i = 1;
1945    else if (dir == ELM_FLIP_DIRECTION_LEFT) i = 2;
1946    else if (dir == ELM_FLIP_DIRECTION_RIGHT) i = 3;
1947    if (i < 0) return;
1948    if (hitsize < 0.0) hitsize = 0.0;
1949    else if (hitsize > 1.0) hitsize = 1.0;
1950    if (wd->dir_hitsize[i] == hitsize) return;
1951    wd->dir_hitsize[i] = hitsize;
1952    _sizing_eval(obj);
1953    _configure(obj);
1954 }
1955
1956 EAPI double
1957 elm_flip_interaction_direction_hitsize_get(Evas_Object *obj, Elm_Flip_Direction dir)
1958 {
1959    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1960    Widget_Data *wd = elm_widget_data_get(obj);
1961    int i = -1;
1962    if (!wd) return 0.0;
1963    if (dir == ELM_FLIP_DIRECTION_UP) i = 0;
1964    else if (dir == ELM_FLIP_DIRECTION_DOWN) i = 1;
1965    else if (dir == ELM_FLIP_DIRECTION_LEFT) i = 2;
1966    else if (dir == ELM_FLIP_DIRECTION_RIGHT) i = 3;
1967    if (i < 0) return 0.0;
1968    return wd->dir_hitsize[i];
1969 }