wearable/src/lib/elm_photocam.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3 #include "elm_widget_photocam.h"
   4
   5 /*
   6  * TODO (maybe - optional future stuff):
   7  *
   8  * 1. wrap photo in theme edje so u can have styling around photo (like white
   9  *    photo bordering).
  10  * 2. exif handling
  11  * 3. rotation flags in exif handling (nasty! should have rot in evas)
  12  */
  13
  14 EAPI const char ELM_PHOTOCAM_SMART_NAME[] = "elm_photocam";
  15 EAPI const char ELM_PHOTOCAM_PAN_SMART_NAME[] = "elm_photocam_pan";
  16
  17 static const char SIG_CLICKED[] = "clicked";
  18 static const char SIG_PRESS[] = "press";
  19 static const char SIG_LONGPRESSED[] = "longpressed";
  20 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
  21 static const char SIG_LOAD[] = "load";
  22 static const char SIG_LOADED[] = "loaded";
  23 static const char SIG_LOAD_DETAIL[] = "load,detail";
  24 static const char SIG_LOADED_DETAIL[] = "loaded,detail";
  25 static const char SIG_ZOOM_START[] = "zoom,start";
  26 static const char SIG_ZOOM_STOP[] = "zoom,stop";
  27 static const char SIG_ZOOM_CHANGE[] = "zoom,change";
  28 static const char SIG_SCROLL[] = "scroll";
  29 static const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
  30 static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
  31 static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
  32 static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
  33 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
  34    {SIG_CLICKED, ""},
  35    {SIG_PRESS, ""},
  36    {SIG_LONGPRESSED, ""},
  37    {SIG_CLICKED_DOUBLE, ""},
  38    {SIG_LOAD, ""},
  39    {SIG_LOADED, ""},
  40    {SIG_LOAD_DETAIL, ""},
  41    {SIG_LOADED_DETAIL, ""},
  42    {SIG_ZOOM_START, ""},
  43    {SIG_ZOOM_STOP, ""},
  44    {SIG_ZOOM_CHANGE, ""},
  45    {SIG_SCROLL, ""},
  46    {SIG_SCROLL_ANIM_START, ""},
  47    {SIG_SCROLL_ANIM_STOP, ""},
  48    {SIG_SCROLL_DRAG_START, ""},
  49    {SIG_SCROLL_DRAG_STOP, ""},
  50    {NULL, NULL}
  51 };
  52
  53 static const Evas_Smart_Interface *_smart_interfaces[] =
  54 {
  55    (Evas_Smart_Interface *)&ELM_SCROLLABLE_IFACE, NULL
  56 };
  57
  58 EVAS_SMART_SUBCLASS_IFACE_NEW
  59   (ELM_PHOTOCAM_SMART_NAME, _elm_photocam, Elm_Photocam_Smart_Class,
  60   Elm_Widget_Smart_Class, elm_widget_smart_class_get, _smart_callbacks,
  61   _smart_interfaces);
  62
  63 ELM_INTERNAL_SMART_SUBCLASS_NEW
  64   (ELM_PHOTOCAM_PAN_SMART_NAME, _elm_photocam_pan,
  65   Elm_Photocam_Pan_Smart_Class, Elm_Pan_Smart_Class, elm_pan_smart_class_get,
  66   NULL);
  67
  68 static void
  69 _sizing_eval(Evas_Object *obj)
  70 {
  71    Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
  72
  73    ELM_PHOTOCAM_DATA_GET(obj, sd);
  74
  75    evas_object_size_hint_max_get
  76      (ELM_WIDGET_DATA(sd)->resize_obj, &maxw, &maxh);
  77    evas_object_size_hint_min_set(obj, minw, minh);
  78    evas_object_size_hint_max_set(obj, maxw, maxh);
  79 }
  80
  81 static void
  82 _calc_job_cb(void *data)
  83 {
  84    Elm_Photocam_Smart_Data *sd = data;
  85    Evas_Coord minw, minh;
  86
  87    minw = sd->size.w;
  88    minh = sd->size.h;
  89    if (sd->resized)
  90      {
  91         sd->resized = EINA_FALSE;
  92         if (sd->mode != ELM_PHOTOCAM_ZOOM_MODE_MANUAL)
  93           {
  94              double tz = sd->zoom;
  95              sd->zoom = 0.0;
  96              elm_photocam_zoom_set(ELM_WIDGET_DATA(sd)->obj, tz);
  97           }
  98      }
  99    if ((minw != sd->minw) || (minh != sd->minh))
 100      {
 101         sd->minw = minw;
 102         sd->minh = minh;
 103
 104         evas_object_smart_callback_call(sd->pan_obj, "changed", NULL);
 105         _sizing_eval(ELM_WIDGET_DATA(sd)->obj);
 106      }
 107    sd->calc_job = NULL;
 108    evas_object_smart_changed(sd->pan_obj);
 109 }
 110
 111 static void
 112 _elm_photocam_pan_smart_add(Evas_Object *obj)
 113 {
 114    /* here just to allocate our extended data */
 115    EVAS_SMART_DATA_ALLOC(obj, Elm_Photocam_Pan_Smart_Data);
 116
 117    ELM_PAN_CLASS(_elm_photocam_pan_parent_sc)->base.add(obj);
 118 }
 119
 120 static void
 121 _elm_photocam_pan_smart_move(Evas_Object *obj,
 122                              Evas_Coord x __UNUSED__,
 123                              Evas_Coord y __UNUSED__)
 124 {
 125    ELM_PHOTOCAM_PAN_DATA_GET(obj, psd);
 126
 127    if (psd->wsd->calc_job) ecore_job_del(psd->wsd->calc_job);
 128    psd->wsd->calc_job = ecore_job_add(_calc_job_cb, psd->wsd);
 129 }
 130
 131 static void
 132 _elm_photocam_pan_smart_resize(Evas_Object *obj,
 133                                Evas_Coord w,
 134                                Evas_Coord h)
 135 {
 136    Evas_Coord ow, oh;
 137
 138    ELM_PHOTOCAM_PAN_DATA_GET(obj, psd);
 139
 140    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
 141    if ((ow == w) && (oh == h)) return;
 142
 143    psd->wsd->resized = EINA_TRUE;
 144    if (psd->wsd->calc_job) ecore_job_del(psd->wsd->calc_job);
 145    psd->wsd->calc_job = ecore_job_add(_calc_job_cb, psd->wsd);
 146 }
 147
 148 static void
 149 _image_place(Evas_Object *obj,
 150              Evas_Coord px,
 151              Evas_Coord py,
 152              Evas_Coord ox,
 153              Evas_Coord oy,
 154              Evas_Coord ow,
 155              Evas_Coord oh)
 156 {
 157    Evas_Coord ax, ay, gw, gh;
 158
 159    ELM_PHOTOCAM_DATA_GET(obj, sd);
 160
 161    ax = 0;
 162    ay = 0;
 163    gw = sd->size.w;
 164    gh = sd->size.h;
 165    if (!sd->zoom_g_layer)
 166      {
 167         if (ow > gw) ax = (ow - gw) / 2;
 168         if (oh > gh) ay = (oh - gh) / 2;
 169      }
 170    evas_object_move(sd->img, ox + 0 - px + ax, oy + 0 - py + ay);
 171    evas_object_resize(sd->img, gw, gh);
 172
 173    if (sd->show.show)
 174      {
 175         sd->show.show = EINA_FALSE;
 176         sd->s_iface->content_region_show
 177           (obj, sd->show.x, sd->show.y, sd->show.w, sd->show.h);
 178      }
 179 }
 180
 181 static void
 182 _grid_load(Evas_Object *obj,
 183            Elm_Phocam_Grid *g)
 184 {
 185    int x, y;
 186    Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh, gw, gh, tx, ty;
 187
 188    ELM_PHOTOCAM_DATA_GET(obj, sd);
 189
 190    evas_object_geometry_get(sd->pan_obj, &ox, &oy, &ow, &oh);
 191    evas_output_viewport_get(evas_object_evas_get(obj), &cvx, &cvy, &cvw, &cvh);
 192
 193    gw = sd->size.w;
 194    gh = sd->size.h;
 195    for (y = 0; y < g->gh; y++)
 196      {
 197         for (x = 0; x < g->gw; x++)
 198           {
 199              int tn, xx, yy, ww, hh;
 200              Eina_Bool visible = EINA_FALSE;
 201
 202              tn = (y * g->gw) + x;
 203              xx = g->grid[tn].out.x;
 204              yy = g->grid[tn].out.y;
 205              ww = g->grid[tn].out.w;
 206              hh = g->grid[tn].out.h;
 207              if ((gw != g->w) && (g->w > 0))
 208                {
 209                   tx = xx;
 210                   xx = (gw * xx) / g->w;
 211                   ww = ((gw * (tx + ww)) / g->w) - xx;
 212                }
 213              if ((gh != g->h) && (g->h > 0))
 214                {
 215                   ty = yy;
 216                   yy = (gh * yy) / g->h;
 217                   hh = ((gh * (ty + hh)) / g->h) - yy;
 218                }
 219              if (ELM_RECTS_INTERSECT(xx - sd->pan_x + ox,
 220                                      yy - sd->pan_y + oy,
 221                                      ww, hh, cvx, cvy, cvw, cvh))
 222                visible = EINA_TRUE;
 223              if ((visible) && (!g->grid[tn].have) && (!g->grid[tn].want))
 224                {
 225                   g->grid[tn].want = 1;
 226                   evas_object_hide(g->grid[tn].img);
 227                   evas_object_image_file_set(g->grid[tn].img, NULL, NULL);
 228                   evas_object_image_load_scale_down_set
 229                     (g->grid[tn].img, g->zoom);
 230                   evas_object_image_load_region_set
 231                     (g->grid[tn].img, g->grid[tn].src.x, g->grid[tn].src.y,
 232                     g->grid[tn].src.w, g->grid[tn].src.h);
 233                   evas_object_image_file_set(g->grid[tn].img, sd->file, NULL);
 234                   evas_object_image_preload(g->grid[tn].img, 0);
 235                   sd->preload_num++;
 236                   if (sd->preload_num == 1)
 237                     {
 238                        edje_object_signal_emit
 239                          (ELM_WIDGET_DATA(sd)->resize_obj,
 240                          "elm,state,busy,start", "elm");
 241                        evas_object_smart_callback_call
 242                          (obj, SIG_LOAD_DETAIL, NULL);
 243                     }
 244                }
 245              else if ((g->grid[tn].want) && (!visible))
 246                {
 247                   sd->preload_num--;
 248                   if (!sd->preload_num)
 249                     {
 250                        edje_object_signal_emit
 251                          (ELM_WIDGET_DATA(sd)->resize_obj,
 252                          "elm,state,busy,stop", "elm");
 253                        evas_object_smart_callback_call
 254                          (obj, SIG_LOADED_DETAIL, NULL);
 255                     }
 256                   g->grid[tn].want = 0;
 257                   evas_object_hide(g->grid[tn].img);
 258                   evas_object_image_preload(g->grid[tn].img, 1);
 259                   evas_object_image_file_set(g->grid[tn].img, NULL, NULL);
 260                }
 261              else if ((g->grid[tn].have) && (!visible))
 262                {
 263                   g->grid[tn].have = 0;
 264                   evas_object_hide(g->grid[tn].img);
 265                   evas_object_image_preload(g->grid[tn].img, 1);
 266                   evas_object_image_file_set(g->grid[tn].img, NULL, NULL);
 267                }
 268           }
 269      }
 270 }
 271
 272 static void
 273 _grid_place(Evas_Object *obj,
 274             Elm_Phocam_Grid *g,
 275             Evas_Coord px,
 276             Evas_Coord py,
 277             Evas_Coord ox,
 278             Evas_Coord oy,
 279             Evas_Coord ow,
 280             Evas_Coord oh)
 281 {
 282    Evas_Coord ax, ay, gw, gh, tx, ty;
 283    int x, y;
 284
 285    ELM_PHOTOCAM_DATA_GET(obj, sd);
 286
 287    ax = 0;
 288    ay = 0;
 289    gw = sd->size.w;
 290    gh = sd->size.h;
 291    if (!sd->zoom_g_layer)
 292      {
 293         if (ow > gw) ax = (ow - gw) / 2;
 294         if (oh > gh) ay = (oh - gh) / 2;
 295      }
 296    for (y = 0; y < g->gh; y++)
 297      {
 298         for (x = 0; x < g->gw; x++)
 299           {
 300              int tn, xx, yy, ww, hh;
 301
 302              tn = (y * g->gw) + x;
 303              xx = g->grid[tn].out.x;
 304              yy = g->grid[tn].out.y;
 305              ww = g->grid[tn].out.w;
 306              hh = g->grid[tn].out.h;
 307              if ((gw != g->w) && (g->w > 0))
 308                {
 309                   tx = xx;
 310                   xx = (gw * xx) / g->w;
 311                   ww = ((gw * (tx + ww)) / g->w) - xx;
 312                }
 313              if ((gh != g->h) && (g->h > 0))
 314                {
 315                   ty = yy;
 316                   yy = (gh * yy) / g->h;
 317                   hh = ((gh * (ty + hh)) / g->h) - yy;
 318                }
 319              evas_object_move(g->grid[tn].img,
 320                               ox + xx - px + ax,
 321                               oy + yy - py + ay);
 322              evas_object_resize(g->grid[tn].img, ww, hh);
 323           }
 324      }
 325 }
 326
 327 static void
 328 _elm_photocam_pan_smart_calculate(Evas_Object *obj)
 329 {
 330    Elm_Phocam_Grid *g;
 331    Eina_List *l;
 332    Evas_Coord ox, oy, ow, oh;
 333
 334    ELM_PHOTOCAM_PAN_DATA_GET(obj, psd);
 335
 336    evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
 337    _image_place(
 338        ELM_WIDGET_DATA(psd->wsd)->obj, psd->wsd->pan_x, psd->wsd->pan_y,
 339        ox - psd->wsd->g_layer_zoom.imx, oy - psd->wsd->g_layer_zoom.imy, ow,
 340        oh);
 341
 342    EINA_LIST_FOREACH(psd->wsd->grids, l, g)
 343      {
 344         _grid_load(ELM_WIDGET_DATA(psd->wsd)->obj, g);
 345         _grid_place(
 346             ELM_WIDGET_DATA(psd->wsd)->obj, g, psd->wsd->pan_x,
 347              psd->wsd->pan_y, ox - psd->wsd->g_layer_zoom.imx,
 348              oy - psd->wsd->g_layer_zoom.imy, ow, oh);
 349      }
 350 }
 351
 352 static void
 353 _elm_photocam_pan_smart_pos_set(Evas_Object *obj,
 354                                 Evas_Coord x,
 355                                 Evas_Coord y)
 356 {
 357    ELM_PHOTOCAM_PAN_DATA_GET(obj, psd);
 358
 359    if ((x == psd->wsd->pan_x) && (y == psd->wsd->pan_y)) return;
 360    psd->wsd->pan_x = x;
 361    psd->wsd->pan_y = y;
 362    evas_object_smart_changed(obj);
 363 }
 364
 365 static void
 366 _elm_photocam_pan_smart_pos_get(const Evas_Object *obj,
 367                                 Evas_Coord *x,
 368                                 Evas_Coord *y)
 369 {
 370    ELM_PHOTOCAM_PAN_DATA_GET(obj, psd);
 371
 372    if (x) *x = psd->wsd->pan_x;
 373    if (y) *y = psd->wsd->pan_y;
 374 }
 375
 376 static void
 377 _elm_photocam_pan_smart_pos_max_get(const Evas_Object *obj,
 378                                     Evas_Coord *x,
 379                                     Evas_Coord *y)
 380 {
 381    Evas_Coord ow, oh;
 382
 383    ELM_PHOTOCAM_PAN_DATA_GET(obj, psd);
 384
 385    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
 386    ow = psd->wsd->minw - ow;
 387    if (ow < 0) ow = 0;
 388    oh = psd->wsd->minh - oh;
 389    if (oh < 0) oh = 0;
 390    if (x) *x = ow;
 391    if (y) *y = oh;
 392 }
 393
 394 static void
 395 _elm_photocam_pan_smart_pos_min_get(const Evas_Object *obj __UNUSED__,
 396                                     Evas_Coord *x,
 397                                     Evas_Coord *y)
 398 {
 399    if (x) *x = 0;
 400    if (y) *y = 0;
 401 }
 402
 403 static void
 404 _elm_photocam_pan_smart_content_size_get(const Evas_Object *obj,
 405                                          Evas_Coord *w,
 406                                          Evas_Coord *h)
 407 {
 408    ELM_PHOTOCAM_PAN_DATA_GET(obj, psd);
 409
 410    if (w) *w = psd->wsd->minw;
 411    if (h) *h = psd->wsd->minh;
 412 }
 413
 414 static void
 415 _elm_photocam_pan_smart_set_user(Elm_Photocam_Pan_Smart_Class *sc)
 416 {
 417    ELM_PAN_CLASS(sc)->base.add = _elm_photocam_pan_smart_add;
 418    ELM_PAN_CLASS(sc)->base.move = _elm_photocam_pan_smart_move;
 419    ELM_PAN_CLASS(sc)->base.resize = _elm_photocam_pan_smart_resize;
 420    ELM_PAN_CLASS(sc)->base.calculate = _elm_photocam_pan_smart_calculate;
 421
 422    ELM_PAN_CLASS(sc)->pos_set = _elm_photocam_pan_smart_pos_set;
 423    ELM_PAN_CLASS(sc)->pos_get = _elm_photocam_pan_smart_pos_get;
 424    ELM_PAN_CLASS(sc)->pos_max_get = _elm_photocam_pan_smart_pos_max_get;
 425    ELM_PAN_CLASS(sc)->pos_min_get = _elm_photocam_pan_smart_pos_min_get;
 426    ELM_PAN_CLASS(sc)->content_size_get =
 427      _elm_photocam_pan_smart_content_size_get;
 428 }
 429
 430 static int
 431 _nearest_pow2_get(int num)
 432 {
 433    unsigned int n = num - 1;
 434
 435    n |= n >> 1;
 436    n |= n >> 2;
 437    n |= n >> 4;
 438    n |= n >> 8;
 439    n |= n >> 16;
 440
 441    return n + 1;
 442 }
 443
 444 static void
 445 _grid_clear(Evas_Object *obj,
 446             Elm_Phocam_Grid *g)
 447 {
 448    int x, y;
 449
 450    ELM_PHOTOCAM_DATA_GET(obj, sd);
 451
 452    if (!g->grid) return;
 453    for (y = 0; y < g->gh; y++)
 454      {
 455         for (x = 0; x < g->gw; x++)
 456           {
 457              int tn;
 458
 459              tn = (y * g->gw) + x;
 460              evas_object_del(g->grid[tn].img);
 461              if (g->grid[tn].want)
 462                {
 463                   sd->preload_num--;
 464                   if (!sd->preload_num)
 465                     {
 466                        edje_object_signal_emit
 467                          (ELM_WIDGET_DATA(sd)->resize_obj,
 468                          "elm,state,busy,stop", "elm");
 469                        evas_object_smart_callback_call
 470                          (obj, SIG_LOAD_DETAIL, NULL);
 471                     }
 472                }
 473           }
 474      }
 475
 476    free(g->grid);
 477    g->grid = NULL;
 478    g->gw = 0;
 479    g->gh = 0;
 480 }
 481
 482 static void
 483 _tile_preloaded_cb(void *data,
 484                    Evas *e __UNUSED__,
 485                    Evas_Object *o __UNUSED__,
 486                    void *event_info __UNUSED__)
 487 {
 488    Elm_Photocam_Grid_Item *git = data;
 489
 490    if (git->want)
 491      {
 492         git->want = 0;
 493         evas_object_show(git->img);
 494         git->have = 1;
 495         git->sd->preload_num--;
 496         if (!git->sd->preload_num)
 497           {
 498              edje_object_signal_emit
 499                (ELM_WIDGET_DATA(git->sd)->resize_obj, "elm,state,busy,stop",
 500                "elm");
 501              evas_object_smart_callback_call
 502                (ELM_WIDGET_DATA(git->sd)->obj, SIG_LOADED_DETAIL, NULL);
 503           }
 504      }
 505 }
 506
 507 static int
 508 _grid_zoom_calc(double zoom)
 509 {
 510    int z = zoom;
 511
 512    if (z < 1) z = 1;
 513    return _nearest_pow2_get(z);
 514 }
 515
 516 static Elm_Phocam_Grid *
 517 _grid_create(Evas_Object *obj)
 518 {
 519    int x, y;
 520    Elm_Phocam_Grid *g;
 521
 522    ELM_PHOTOCAM_DATA_GET(obj, sd);
 523
 524    g = calloc(1, sizeof(Elm_Phocam_Grid));
 525    if (!g) return NULL;
 526
 527    g->zoom = _grid_zoom_calc(sd->zoom);
 528    g->tsize = sd->tsize;
 529    g->iw = sd->size.imw;
 530    g->ih = sd->size.imh;
 531
 532    g->w = g->iw / g->zoom;
 533    g->h = g->ih / g->zoom;
 534    if (g->zoom >= 8)
 535      {
 536         free(g);
 537
 538         return NULL;
 539      }
 540    if (sd->do_region)
 541      {
 542         g->gw = (g->w + g->tsize - 1) / g->tsize;
 543         g->gh = (g->h + g->tsize - 1) / g->tsize;
 544      }
 545    else
 546      {
 547         g->gw = 1;
 548         g->gh = 1;
 549      }
 550
 551    g->grid = calloc(1, sizeof(Elm_Photocam_Grid_Item) * g->gw * g->gh);
 552    if (!g->grid)
 553      {
 554         g->gw = 0;
 555         g->gh = 0;
 556
 557         return g;
 558      }
 559
 560    for (y = 0; y < g->gh; y++)
 561      {
 562         for (x = 0; x < g->gw; x++)
 563           {
 564              int tn;
 565
 566              tn = (y * g->gw) + x;
 567              g->grid[tn].src.x = x * g->tsize;
 568              if (x == (g->gw - 1))
 569                g->grid[tn].src.w = g->w - ((g->gw - 1) * g->tsize);
 570              else
 571                g->grid[tn].src.w = g->tsize;
 572              g->grid[tn].src.y = y * g->tsize;
 573              if (y == (g->gh - 1))
 574                g->grid[tn].src.h = g->h - ((g->gh - 1) * g->tsize);
 575              else
 576                g->grid[tn].src.h = g->tsize;
 577
 578              g->grid[tn].out.x = g->grid[tn].src.x;
 579              g->grid[tn].out.y = g->grid[tn].src.y;
 580              g->grid[tn].out.w = g->grid[tn].src.w;
 581              g->grid[tn].out.h = g->grid[tn].src.h;
 582
 583              g->grid[tn].sd = sd;
 584              g->grid[tn].img =
 585                evas_object_image_add(evas_object_evas_get(obj));
 586              evas_object_image_load_orientation_set(g->grid[tn].img, EINA_TRUE);
 587              evas_object_image_scale_hint_set
 588                (g->grid[tn].img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
 589              evas_object_pass_events_set(g->grid[tn].img, EINA_TRUE);
 590
 591              /* XXX: check this */
 592              evas_object_smart_member_add(g->grid[tn].img, sd->pan_obj);
 593              elm_widget_sub_object_add(obj, g->grid[tn].img);
 594              evas_object_image_filled_set(g->grid[tn].img, 1);
 595              evas_object_event_callback_add
 596                (g->grid[tn].img, EVAS_CALLBACK_IMAGE_PRELOADED,
 597                _tile_preloaded_cb, &(g->grid[tn]));
 598           }
 599      }
 600
 601    return g;
 602 }
 603
 604 static void
 605 _grid_clear_all(Evas_Object *obj)
 606 {
 607    Elm_Phocam_Grid *g;
 608
 609    ELM_PHOTOCAM_DATA_GET(obj, sd);
 610
 611    EINA_LIST_FREE (sd->grids, g)
 612      {
 613         _grid_clear(obj, g);
 614         free(g);
 615      }
 616 }
 617
 618 static void
 619 _smooth_update(Evas_Object *obj)
 620 {
 621    Elm_Phocam_Grid *g;
 622    int x, y;
 623    Eina_List *l;
 624
 625    ELM_PHOTOCAM_DATA_GET(obj, sd);
 626
 627    EINA_LIST_FOREACH(sd->grids, l, g)
 628      {
 629         for (y = 0; y < g->gh; y++)
 630           {
 631              for (x = 0; x < g->gw; x++)
 632                {
 633                   int tn;
 634
 635                   tn = (y * g->gw) + x;
 636                   evas_object_image_smooth_scale_set
 637                     (g->grid[tn].img, (!sd->no_smooth));
 638                }
 639           }
 640      }
 641
 642    evas_object_image_smooth_scale_set(sd->img, (!sd->no_smooth));
 643 }
 644
 645 static void
 646 _grid_raise(Elm_Phocam_Grid *g)
 647 {
 648    int x, y;
 649
 650    for (y = 0; y < g->gh; y++)
 651      {
 652         for (x = 0; x < g->gw; x++)
 653           {
 654              int tn;
 655
 656              tn = (y * g->gw) + x;
 657              evas_object_raise(g->grid[tn].img);
 658           }
 659      }
 660 }
 661
 662 static Eina_Bool
 663 _scroll_timeout_cb(void *data)
 664 {
 665    ELM_PHOTOCAM_DATA_GET(data, sd);
 666
 667    sd->no_smooth--;
 668    if (!sd->no_smooth) _smooth_update(data);
 669
 670    sd->scr_timer = NULL;
 671
 672    return ECORE_CALLBACK_CANCEL;
 673 }
 674
 675 static void
 676 _main_img_preloaded_cb(void *data,
 677                        Evas *e __UNUSED__,
 678                        Evas_Object *o __UNUSED__,
 679                        void *event_info __UNUSED__)
 680 {
 681    Evas_Object *obj = data;
 682    Elm_Phocam_Grid *g;
 683
 684    ELM_PHOTOCAM_DATA_GET(data, sd);
 685
 686    evas_object_show(sd->img);
 687    sd->main_load_pending = 0;
 688    g = _grid_create(obj);
 689    if (g)
 690      {
 691         sd->grids = eina_list_prepend(sd->grids, g);
 692         _grid_load(obj, g);
 693      }
 694    if (sd->calc_job) ecore_job_del(sd->calc_job);
 695    sd->calc_job = ecore_job_add(_calc_job_cb, sd);
 696    evas_object_smart_callback_call(data, SIG_LOADED, NULL);
 697    sd->preload_num--;
 698    if (!sd->preload_num)
 699      {
 700         edje_object_signal_emit
 701           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,state,busy,stop", "elm");
 702         evas_object_smart_callback_call(obj, SIG_LOADED_DETAIL, NULL);
 703      }
 704 }
 705
 706 static Eina_Bool
 707 _zoom_do(Evas_Object *obj,
 708          double t)
 709 {
 710    Evas_Coord xx, yy, ow, oh;
 711
 712    ELM_PHOTOCAM_DATA_GET(obj, sd);
 713
 714    sd->size.w = (sd->size.ow * (1.0 - t)) + (sd->size.nw * t);
 715    sd->size.h = (sd->size.oh * (1.0 - t)) + (sd->size.nh * t);
 716    sd->s_iface->content_viewport_size_get(obj, &ow, &oh);
 717    xx = (sd->size.spos.x * sd->size.w) - (ow / 2);
 718    yy = (sd->size.spos.y * sd->size.h) - (oh / 2);
 719    if (xx < 0) xx = 0;
 720    else if (xx > (sd->size.w - ow))
 721      xx = sd->size.w - ow;
 722    if (yy < 0) yy = 0;
 723    else if (yy > (sd->size.h - oh))
 724      yy = sd->size.h - oh;
 725
 726    sd->show.show = EINA_TRUE;
 727    sd->show.x = xx;
 728    sd->show.y = yy;
 729    sd->show.w = ow;
 730    sd->show.h = oh;
 731
 732    if (sd->calc_job) ecore_job_del(sd->calc_job);
 733    sd->calc_job = ecore_job_add(_calc_job_cb, sd);
 734    if (t >= 1.0)
 735      {
 736         Eina_List *l, *l_next;
 737         Elm_Phocam_Grid *g;
 738
 739         EINA_LIST_FOREACH_SAFE(sd->grids, l, l_next, g)
 740           {
 741              if (g->dead)
 742                {
 743                   sd->grids = eina_list_remove_list(sd->grids, l);
 744                   _grid_clear(obj, g);
 745                   free(g);
 746                }
 747           }
 748         return EINA_FALSE;
 749      }
 750
 751    return EINA_TRUE;
 752 }
 753
 754 static Eina_Bool
 755 _zoom_anim_cb(void *data)
 756 {
 757    double t;
 758    Eina_Bool go;
 759    Evas_Object *obj = data;
 760
 761    ELM_PHOTOCAM_DATA_GET(obj, sd);
 762
 763    t = ecore_loop_time_get();
 764    if (t >= sd->t_end)
 765      t = 1.0;
 766    else if (sd->t_end > sd->t_start)
 767      t = (t - sd->t_start) / (sd->t_end - sd->t_start);
 768    else
 769      t = 1.0;
 770    t = 1.0 - t;
 771    t = 1.0 - (t * t);
 772    go = _zoom_do(obj, t);
 773    if (!go)
 774      {
 775         sd->no_smooth--;
 776         if (!sd->no_smooth) _smooth_update(data);
 777         sd->zoom_animator = NULL;
 778         evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
 779      }
 780
 781    return go;
 782 }
 783
 784 static Eina_Bool
 785 _long_press_cb(void *data)
 786 {
 787    ELM_PHOTOCAM_DATA_GET(data, sd);
 788
 789    sd->long_timer = NULL;
 790    sd->longpressed = EINA_TRUE;
 791    evas_object_smart_callback_call(data, SIG_LONGPRESSED, NULL);
 792
 793    return ECORE_CALLBACK_CANCEL;
 794 }
 795
 796 static void
 797 _mouse_down_cb(void *data,
 798                Evas *evas __UNUSED__,
 799                Evas_Object *obj __UNUSED__,
 800                void *event_info)
 801 {
 802    Evas_Event_Mouse_Down *ev = event_info;
 803
 804    ELM_PHOTOCAM_DATA_GET(data, sd);
 805
 806    if (ev->button != 1) return;
 807    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) sd->on_hold = EINA_TRUE;
 808    else sd->on_hold = EINA_FALSE;
 809    if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
 810      evas_object_smart_callback_call(data, SIG_CLICKED_DOUBLE, NULL);
 811    else
 812      evas_object_smart_callback_call(data, SIG_PRESS, NULL);
 813    sd->longpressed = EINA_FALSE;
 814    if (sd->long_timer) ecore_timer_del(sd->long_timer);
 815    sd->long_timer = ecore_timer_add
 816        (_elm_config->longpress_timeout, _long_press_cb, data);
 817 }
 818
 819 static void
 820 _mouse_up_cb(void *data,
 821              Evas *evas __UNUSED__,
 822              Evas_Object *obj __UNUSED__,
 823              void *event_info)
 824 {
 825    Evas_Event_Mouse_Up *ev = event_info;
 826
 827    ELM_PHOTOCAM_DATA_GET(data, sd);
 828
 829    if (ev->button != 1) return;
 830    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) sd->on_hold = EINA_TRUE;
 831    else sd->on_hold = EINA_FALSE;
 832    if (sd->long_timer)
 833      {
 834         ecore_timer_del(sd->long_timer);
 835         sd->long_timer = NULL;
 836      }
 837    if (!sd->on_hold)
 838      evas_object_smart_callback_call(data, SIG_CLICKED, NULL);
 839    sd->on_hold = EINA_FALSE;
 840 }
 841
 842 static Eina_Bool
 843 _elm_photocam_smart_on_focus(Evas_Object *obj)
 844 {
 845    ELM_PHOTOCAM_DATA_GET(obj, sd);
 846
 847    if (elm_widget_focus_get(obj))
 848      {
 849         edje_object_signal_emit
 850           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,action,focus", "elm");
 851         evas_object_focus_set(ELM_WIDGET_DATA(sd)->resize_obj, EINA_TRUE);
 852      }
 853    else
 854      {
 855         edje_object_signal_emit
 856           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,action,unfocus", "elm");
 857         evas_object_focus_set(ELM_WIDGET_DATA(sd)->resize_obj, EINA_FALSE);
 858      }
 859
 860    return EINA_TRUE;
 861 }
 862
 863 static Eina_Bool
 864 _elm_photocam_smart_theme(Evas_Object *obj)
 865 {
 866    if (!ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->theme(obj))
 867      return EINA_FALSE;
 868
 869    _sizing_eval(obj);
 870
 871    return EINA_TRUE;
 872 }
 873
 874 static void
 875 _scroll_animate_start_cb(Evas_Object *obj,
 876                          void *data __UNUSED__)
 877 {
 878    evas_object_smart_callback_call(obj, SIG_SCROLL_ANIM_START, NULL);
 879 }
 880
 881 static void
 882 _scroll_animate_stop_cb(Evas_Object *obj,
 883                         void *data __UNUSED__)
 884 {
 885    evas_object_smart_callback_call(obj, SIG_SCROLL_ANIM_STOP, NULL);
 886 }
 887
 888 static void
 889 _scroll_drag_start_cb(Evas_Object *obj,
 890                       void *data __UNUSED__)
 891 {
 892    evas_object_smart_callback_call(obj, SIG_SCROLL_DRAG_START, NULL);
 893 }
 894
 895 static void
 896 _scroll_drag_stop_cb(Evas_Object *obj,
 897                      void *data __UNUSED__)
 898 {
 899    evas_object_smart_callback_call(obj, SIG_SCROLL_DRAG_STOP, NULL);
 900 }
 901
 902 static void
 903 _scroll_cb(Evas_Object *obj,
 904            void *data __UNUSED__)
 905 {
 906    ELM_PHOTOCAM_DATA_GET(obj, sd);
 907
 908    if (!sd->scr_timer)
 909      {
 910         sd->no_smooth++;
 911         if (sd->no_smooth == 1) _smooth_update(obj);
 912      }
 913
 914    if (sd->scr_timer) ecore_timer_del(sd->scr_timer);
 915    sd->scr_timer = ecore_timer_add(0.5, _scroll_timeout_cb, obj);
 916
 917    evas_object_smart_callback_call(obj, SIG_SCROLL, NULL);
 918 }
 919
 920 static Eina_Bool
 921 _elm_photocam_smart_event(Evas_Object *obj,
 922                           Evas_Object *src __UNUSED__,
 923                           Evas_Callback_Type type,
 924                           void *event_info)
 925 {
 926    double zoom;
 927    Evas_Coord x = 0;
 928    Evas_Coord y = 0;
 929    Evas_Coord v_w = 0;
 930    Evas_Coord v_h = 0;
 931    Evas_Coord step_x = 0;
 932    Evas_Coord step_y = 0;
 933    Evas_Coord page_x = 0;
 934    Evas_Coord page_y = 0;
 935    Evas_Event_Key_Down *ev = event_info;
 936
 937    ELM_PHOTOCAM_DATA_GET(obj, sd);
 938
 939    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 940
 941    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
 942    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 943
 944    sd->s_iface->content_pos_get(obj, &x, &y);
 945    sd->s_iface->step_size_get(obj, &step_x, &step_y);
 946    sd->s_iface->page_size_get(obj, &page_x, &page_y);
 947    sd->s_iface->content_viewport_size_get(obj, &v_w, &v_h);
 948
 949    if ((!strcmp(ev->keyname, "Left")) ||
 950        ((!strcmp(ev->keyname, "KP_Left")) && (!ev->string)))
 951      {
 952         x -= step_x;
 953      }
 954    else if ((!strcmp(ev->keyname, "Right")) ||
 955             ((!strcmp(ev->keyname, "KP_Right")) && (!ev->string)))
 956      {
 957         x += step_x;
 958      }
 959    else if ((!strcmp(ev->keyname, "Up")) ||
 960             ((!strcmp(ev->keyname, "KP_Up")) && (!ev->string)))
 961      {
 962         y -= step_y;
 963      }
 964    else if ((!strcmp(ev->keyname, "Down")) ||
 965             ((!strcmp(ev->keyname, "KP_Down")) && (!ev->string)))
 966      {
 967         y += step_y;
 968      }
 969    else if ((!strcmp(ev->keyname, "Prior")) ||
 970             ((!strcmp(ev->keyname, "KP_Prior")) && (!ev->string)))
 971      {
 972         if (page_y < 0)
 973           y -= -(page_y * v_h) / 100;
 974         else
 975           y -= page_y;
 976      }
 977    else if ((!strcmp(ev->keyname, "Next")) ||
 978             ((!strcmp(ev->keyname, "KP_Next")) && (!ev->string)))
 979      {
 980         if (page_y < 0)
 981           y += -(page_y * v_h) / 100;
 982         else
 983           y += page_y;
 984      }
 985    else if ((!strcmp(ev->keyname, "KP_Add")))
 986      {
 987         zoom = elm_photocam_zoom_get(obj);
 988         zoom -= 0.5;
 989         elm_photocam_zoom_mode_set(obj, ELM_PHOTOCAM_ZOOM_MODE_MANUAL);
 990         elm_photocam_zoom_set(obj, zoom);
 991         return EINA_TRUE;
 992      }
 993    else if ((!strcmp(ev->keyname, "KP_Subtract")))
 994      {
 995         zoom = elm_photocam_zoom_get(obj);
 996         zoom += 0.5;
 997         elm_photocam_zoom_mode_set(obj, ELM_PHOTOCAM_ZOOM_MODE_MANUAL);
 998         elm_photocam_zoom_set(obj, zoom);
 999         return EINA_TRUE;
1000      }
1001    else return EINA_FALSE;
1002
1003    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
1004    sd->s_iface->content_pos_set(obj, x, y, EINA_TRUE);
1005
1006    return EINA_TRUE;
1007 }
1008
1009 Eina_Bool
1010 _bounce_eval(void *data)
1011 {
1012    Elm_Photocam_Smart_Data *sd = data;
1013    double t, tt;
1014
1015    if ((sd->g_layer_zoom.imx == sd->g_layer_zoom.bounce.x_end) &&
1016        (sd->g_layer_zoom.imy == sd->g_layer_zoom.bounce.y_end))
1017      {
1018         sd->g_layer_zoom.imx = 0;
1019         sd->g_layer_zoom.imy = 0;
1020         sd->zoom_g_layer = EINA_FALSE;
1021         sd->g_layer_zoom.bounce.animator = NULL;
1022
1023         sd->s_iface->freeze_set(ELM_WIDGET_DATA(sd)->obj, EINA_FALSE);
1024
1025         return ECORE_CALLBACK_CANCEL;
1026      }
1027
1028    t = ecore_loop_time_get();
1029    tt = (t - sd->g_layer_zoom.bounce.t_start) /
1030      (sd->g_layer_zoom.bounce.t_end -
1031       sd->g_layer_zoom.bounce.t_start);
1032    tt = 1.0 - tt;
1033    tt = 1.0 - (tt * tt);
1034
1035    if (t > sd->g_layer_zoom.bounce.t_end)
1036      {
1037         sd->g_layer_zoom.imx = 0;
1038         sd->g_layer_zoom.imy = 0;
1039         sd->zoom_g_layer = EINA_FALSE;
1040
1041         sd->s_iface->freeze_set(ELM_WIDGET_DATA(sd)->obj, EINA_FALSE);
1042
1043         _zoom_do(ELM_WIDGET_DATA(sd)->obj, 1.0);
1044         sd->g_layer_zoom.bounce.animator = NULL;
1045         return ECORE_CALLBACK_CANCEL;
1046      }
1047
1048    if (sd->g_layer_zoom.imx != sd->g_layer_zoom.bounce.x_end)
1049      sd->g_layer_zoom.imx =
1050        sd->g_layer_zoom.bounce.x_start * (1.0 - tt) +
1051        sd->g_layer_zoom.bounce.x_end * tt;
1052
1053    if (sd->g_layer_zoom.imy != sd->g_layer_zoom.bounce.y_end)
1054      sd->g_layer_zoom.imy =
1055        sd->g_layer_zoom.bounce.y_start * (1.0 - tt) +
1056        sd->g_layer_zoom.bounce.y_end * tt;
1057
1058    _zoom_do(ELM_WIDGET_DATA(sd)->obj, 1.0 - (1.0 - tt));
1059
1060    return ECORE_CALLBACK_RENEW;
1061 }
1062
1063 static void
1064 _g_layer_zoom_do(Elm_Photocam_Smart_Data *sd,
1065                  Evas_Coord px,
1066                  Evas_Coord py,
1067                  Elm_Gesture_Zoom_Info *g_layer)
1068 {
1069    int regx, regy, regw, regh, ix, iy, iw, ih;
1070    Evas_Coord rx, ry, rw, rh;
1071    Evas_Object *obj;
1072    int xx, yy;
1073
1074    obj = ELM_WIDGET_DATA(sd)->obj;
1075    sd->mode = ELM_PHOTOCAM_ZOOM_MODE_MANUAL;
1076    sd->zoom = sd->g_layer_start / g_layer->zoom;
1077    sd->size.ow = sd->size.w;
1078    sd->size.oh = sd->size.h;
1079    sd->s_iface->content_pos_get(obj, &rx, &ry);
1080    sd->s_iface->content_viewport_size_get(obj, &rw, &rh);
1081    if ((rw <= 0) || (rh <= 0)) return;
1082
1083    sd->size.nw = (double)sd->size.imw / sd->zoom;
1084    sd->size.nh = (double)sd->size.imh / sd->zoom;
1085
1086    elm_photocam_image_region_get(obj, &regx, &regy, &regw, &regh);
1087    evas_object_geometry_get(sd->img, &ix, &iy, &iw, &ih);
1088
1089    sd->pvx = g_layer->x;
1090    sd->pvy = g_layer->y;
1091
1092    xx = (px / sd->zoom) - sd->pvx;
1093    yy = (py / sd->zoom) - sd->pvy;
1094    sd->g_layer_zoom.imx = 0;
1095    sd->g_layer_zoom.imy = 0;
1096
1097    if ((xx < 0) || (rw > sd->size.nw))
1098      {
1099         sd->g_layer_zoom.imx = xx;
1100         xx = 0;
1101      }
1102    else if ((xx + rw) > sd->size.nw)
1103      {
1104         sd->g_layer_zoom.imx = xx + rw - sd->size.nw;
1105         xx = sd->size.nw - rw;
1106      }
1107
1108    if ((yy < 0) || (rh > sd->size.nh))
1109      {
1110         sd->g_layer_zoom.imy = yy;
1111         yy = 0;
1112      }
1113    else if ((yy + rh) > sd->size.nh)
1114      {
1115         sd->g_layer_zoom.imy = yy + rh - sd->size.nh;
1116         yy = sd->size.nh - rh;
1117      }
1118
1119    sd->size.spos.x = (double)(xx + (rw / 2)) / (double)(sd->size.nw);
1120    sd->size.spos.y = (double)(yy + (rh / 2)) / (double)(sd->size.nh);
1121
1122    _zoom_do(obj, 1.0);
1123 }
1124
1125 static Evas_Event_Flags
1126 _g_layer_zoom_start_cb(void *data,
1127                        void *event_info)
1128 {
1129    Elm_Gesture_Zoom_Info *p = event_info;
1130    Elm_Photocam_Smart_Data *sd = data;
1131    double marginx = 0, marginy = 0;
1132    Evas_Coord rw, rh;
1133    int x, y, w, h;
1134
1135    if (sd->g_layer_zoom.bounce.animator)
1136      {
1137         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1138         sd->g_layer_zoom.bounce.animator = NULL;
1139      }
1140    sd->zoom_g_layer = EINA_TRUE;
1141
1142    sd->s_iface->freeze_set(ELM_WIDGET_DATA(sd)->obj, EINA_TRUE);
1143
1144    elm_photocam_image_region_get(ELM_WIDGET_DATA(sd)->obj, &x, &y, &w, &h);
1145    sd->s_iface->content_viewport_size_get(ELM_WIDGET_DATA(sd)->obj, &rw, &rh);
1146
1147    if (rw > sd->size.nw)
1148      marginx = (rw - sd->size.nw) / 2;
1149    if (rh > sd->size.nh)
1150      marginy = (rh - sd->size.nh) / 2;
1151
1152    sd->g_layer_start = sd->zoom;
1153
1154    sd->zoom_point_x = x + ((p->x - marginx) * sd->zoom) +
1155      sd->g_layer_zoom.imx;
1156    sd->zoom_point_y = y + ((p->y - marginy) * sd->zoom) +
1157      sd->g_layer_zoom.imy;
1158
1159    return EVAS_EVENT_FLAG_NONE;
1160 }
1161
1162 static Evas_Event_Flags
1163 _g_layer_zoom_move_cb(void *data,
1164                       void *event_info)
1165 {
1166    Elm_Photocam_Smart_Data *sd = data;
1167    Elm_Gesture_Zoom_Info *p = event_info;
1168
1169    _g_layer_zoom_do(sd, sd->zoom_point_x, sd->zoom_point_y, p);
1170
1171    return EVAS_EVENT_FLAG_NONE;
1172 }
1173
1174 static Evas_Event_Flags
1175 _g_layer_zoom_end_cb(void *data,
1176                      void *event_info __UNUSED__)
1177 {
1178    Elm_Photocam_Smart_Data *sd = data;
1179    Evas_Coord rw, rh;
1180
1181    sd->s_iface->content_viewport_size_get(ELM_WIDGET_DATA(sd)->obj, &rw, &rh);
1182    sd->g_layer_start = 1.0;
1183
1184    if (sd->g_layer_zoom.imx || sd->g_layer_zoom.imy)
1185      {
1186         double t;
1187
1188         t = ecore_loop_time_get();
1189         sd->g_layer_zoom.bounce.x_start = sd->g_layer_zoom.imx;
1190         sd->g_layer_zoom.bounce.y_start = sd->g_layer_zoom.imy;
1191         sd->g_layer_zoom.bounce.x_end = 0;
1192         sd->g_layer_zoom.bounce.y_end = 0;
1193
1194         if (rw > sd->size.nw &&
1195             rh > sd->size.nh)
1196           {
1197              Evas_Coord pw, ph;
1198              double z;
1199
1200              if ((sd->size.imw < rw) && (sd->size.imh < rh))
1201                {
1202                   sd->zoom = 1;
1203                   sd->size.nw = sd->size.imw;
1204                   sd->size.nh = sd->size.imh;
1205                }
1206              else
1207                {
1208                   ph = (sd->size.imh * rw) / sd->size.imw;
1209                   if (ph > rh)
1210                     {
1211                        pw = (sd->size.imw * rh) / sd->size.imh;
1212                        ph = rh;
1213                     }
1214                   else
1215                     {
1216                        pw = rw;
1217                     }
1218                   if (sd->size.imw > sd->size.imh)
1219                     z = (double)sd->size.imw / pw;
1220                   else
1221                     z = (double)sd->size.imh / ph;
1222
1223                   sd->zoom = z;
1224                   sd->size.nw = pw;
1225                   sd->size.nh = ph;
1226                }
1227              sd->g_layer_zoom.bounce.x_end = (sd->size.nw - rw) / 2;
1228              sd->g_layer_zoom.bounce.y_end = (sd->size.nh - rh) / 2;
1229           }
1230         else
1231           {
1232              int xx, yy;
1233
1234              xx = (sd->zoom_point_x / sd->zoom) - sd->pvx;
1235              yy = (sd->zoom_point_y / sd->zoom) - sd->pvy;
1236
1237              if (xx < 0) xx = 0;
1238              if (yy < 0) yy = 0;
1239
1240              if (rw > sd->size.nw)
1241                sd->g_layer_zoom.bounce.x_end = (sd->size.nw - rw) / 2;
1242              if ((xx + rw) > sd->size.nw)
1243                xx = sd->size.nw - rw;
1244
1245              if (rh > sd->size.nh)
1246                sd->g_layer_zoom.bounce.y_end = (sd->size.nh - rh) / 2;
1247              if ((yy + rh) > sd->size.nh)
1248                yy = sd->size.nh - rh;
1249
1250              sd->size.spos.x = (double)(xx + (rw / 2)) / (double)(sd->size.nw);
1251              sd->size.spos.y = (double)(yy + (rh / 2)) / (double)(sd->size.nh);
1252           }
1253
1254         sd->g_layer_zoom.bounce.t_start = t;
1255         sd->g_layer_zoom.bounce.t_end = t +
1256           _elm_config->page_scroll_friction;
1257
1258         sd->g_layer_zoom.bounce.animator =
1259           ecore_animator_add(_bounce_eval, sd);
1260      }
1261    else
1262      {
1263         sd->s_iface->freeze_set(ELM_WIDGET_DATA(sd)->obj, EINA_FALSE);
1264         sd->zoom_g_layer = EINA_FALSE;
1265      }
1266
1267    return EVAS_EVENT_FLAG_NONE;
1268 }
1269
1270 static void
1271 _elm_photocam_smart_add(Evas_Object *obj)
1272 {
1273    EVAS_SMART_DATA_ALLOC(obj, Elm_Photocam_Smart_Data);
1274
1275    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.add(obj);
1276 }
1277
1278 static void
1279 _elm_photocam_smart_del(Evas_Object *obj)
1280 {
1281    Elm_Phocam_Grid *g;
1282
1283    ELM_PHOTOCAM_DATA_GET(obj, sd);
1284
1285    EINA_LIST_FREE (sd->grids, g)
1286      {
1287         if (g->grid) free(g->grid);
1288         free(g);
1289      }
1290    evas_object_del(sd->pan_obj);
1291    sd->pan_obj = NULL;
1292
1293    if (sd->file) eina_stringshare_del(sd->file);
1294    if (sd->calc_job) ecore_job_del(sd->calc_job);
1295    if (sd->scr_timer) ecore_timer_del(sd->scr_timer);
1296    if (sd->zoom_animator) ecore_animator_del(sd->zoom_animator);
1297    if (sd->g_layer_zoom.bounce.animator)
1298      ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1299    if (sd->long_timer) ecore_timer_del(sd->long_timer);
1300
1301    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.del(obj);
1302 }
1303
1304 static void
1305 _elm_photocam_smart_move(Evas_Object *obj,
1306                          Evas_Coord x,
1307                          Evas_Coord y)
1308 {
1309    ELM_PHOTOCAM_DATA_GET(obj, sd);
1310
1311    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.move(obj, x, y);
1312
1313    evas_object_move(sd->hit_rect, x, y);
1314 }
1315
1316 static void
1317 _elm_photocam_smart_resize(Evas_Object *obj,
1318                            Evas_Coord w,
1319                            Evas_Coord h)
1320 {
1321    ELM_PHOTOCAM_DATA_GET(obj, sd);
1322
1323    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.resize(obj, w, h);
1324
1325    evas_object_resize(sd->hit_rect, w, h);
1326 }
1327
1328 static void
1329 _elm_photocam_smart_member_add(Evas_Object *obj,
1330                                Evas_Object *member)
1331 {
1332    ELM_PHOTOCAM_DATA_GET(obj, sd);
1333
1334    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.member_add(obj, member);
1335
1336    if (sd->hit_rect)
1337      evas_object_raise(sd->hit_rect);
1338 }
1339
1340 static void
1341 _elm_photocam_smart_set_user(Elm_Photocam_Smart_Class *sc)
1342 {
1343    ELM_WIDGET_CLASS(sc)->base.add = _elm_photocam_smart_add;
1344    ELM_WIDGET_CLASS(sc)->base.del = _elm_photocam_smart_del;
1345    ELM_WIDGET_CLASS(sc)->base.move = _elm_photocam_smart_move;
1346    ELM_WIDGET_CLASS(sc)->base.resize = _elm_photocam_smart_resize;
1347    ELM_WIDGET_CLASS(sc)->base.member_add = _elm_photocam_smart_member_add;
1348
1349    ELM_WIDGET_CLASS(sc)->on_focus = _elm_photocam_smart_on_focus;
1350    ELM_WIDGET_CLASS(sc)->theme = _elm_photocam_smart_theme;
1351    ELM_WIDGET_CLASS(sc)->event = _elm_photocam_smart_event;
1352 }
1353
1354 EAPI const Elm_Photocam_Smart_Class *
1355 elm_photocam_smart_class_get(void)
1356 {
1357    static Elm_Photocam_Smart_Class _sc =
1358      ELM_PHOTOCAM_SMART_CLASS_INIT_NAME_VERSION(ELM_PHOTOCAM_SMART_NAME);
1359    static const Elm_Photocam_Smart_Class *class = NULL;
1360    Evas_Smart_Class *esc = (Evas_Smart_Class *)&_sc;
1361
1362    if (class) return class;
1363
1364    _elm_photocam_smart_set(&_sc);
1365    esc->callbacks = _smart_callbacks;
1366    class = &_sc;
1367
1368    return class;
1369 }
1370
1371 EAPI Evas_Object *
1372 elm_photocam_add(Evas_Object *parent)
1373 {
1374    Evas_Object *obj;
1375    Evas_Coord minw, minh;
1376    Elm_Photocam_Pan_Smart_Data *pan_data;
1377    Eina_Bool bounce = _elm_config->thumbscroll_bounce_enable;
1378
1379    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
1380
1381    obj = elm_widget_add(_elm_photocam_smart_class_new(), parent);
1382    if (!obj) return NULL;
1383
1384    if (!elm_widget_sub_object_add(parent, obj))
1385      ERR("could not add %p as sub object of %p", obj, parent);
1386
1387    ELM_PHOTOCAM_DATA_GET(obj, sd);
1388
1389    Evas_Object *edje = edje_object_add(evas_object_evas_get(obj));
1390    elm_widget_resize_object_set(obj, edje, EINA_TRUE);
1391
1392    elm_widget_theme_object_set
1393      (obj, edje, "photocam", "base", elm_widget_style_get(obj));
1394
1395    sd->hit_rect = evas_object_rectangle_add(evas_object_evas_get(obj));
1396    evas_object_smart_member_add(sd->hit_rect, obj);
1397    elm_widget_sub_object_add(obj, sd->hit_rect);
1398
1399    /* common scroller hit rectangle setup */
1400    evas_object_color_set(sd->hit_rect, 0, 0, 0, 0);
1401    evas_object_show(sd->hit_rect);
1402    evas_object_repeat_events_set(sd->hit_rect, EINA_TRUE);
1403
1404    elm_widget_can_focus_set(obj, EINA_TRUE);
1405
1406    sd->s_iface = evas_object_smart_interface_get
1407        (obj, ELM_SCROLLABLE_IFACE_NAME);
1408
1409    sd->s_iface->objects_set(obj, edje, sd->hit_rect);
1410
1411    sd->s_iface->animate_start_cb_set(obj, _scroll_animate_start_cb);
1412    sd->s_iface->animate_stop_cb_set(obj, _scroll_animate_stop_cb);
1413    sd->s_iface->drag_start_cb_set(obj, _scroll_drag_start_cb);
1414    sd->s_iface->drag_stop_cb_set(obj, _scroll_drag_stop_cb);
1415    sd->s_iface->scroll_cb_set(obj, _scroll_cb);
1416
1417    sd->s_iface->bounce_allow_set(obj, bounce, bounce);
1418
1419    sd->pan_obj = evas_object_smart_add
1420        (evas_object_evas_get(obj), _elm_photocam_pan_smart_class_new());
1421    pan_data = evas_object_smart_data_get(sd->pan_obj);
1422    pan_data->wsd = sd;
1423
1424    sd->s_iface->extern_pan_set(obj, sd->pan_obj);
1425
1426    sd->zoom_g_layer = EINA_FALSE;
1427    sd->g_layer_start = 1.0;
1428    sd->zoom = 1;
1429    sd->mode = ELM_PHOTOCAM_ZOOM_MODE_MANUAL;
1430    sd->tsize = 512;
1431
1432    sd->img = evas_object_image_add(evas_object_evas_get(obj));
1433    evas_object_image_load_orientation_set(sd->img, EINA_TRUE);
1434    evas_object_image_scale_hint_set(sd->img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
1435    evas_object_event_callback_add
1436      (sd->img, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, obj);
1437    evas_object_event_callback_add
1438      (sd->img, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, obj);
1439    evas_object_image_scale_hint_set(sd->img, EVAS_IMAGE_SCALE_HINT_STATIC);
1440
1441    /* XXX: mmm... */
1442    evas_object_smart_member_add(sd->img, sd->pan_obj);
1443
1444    elm_widget_sub_object_add(obj, sd->img);
1445    evas_object_image_filled_set(sd->img, EINA_TRUE);
1446    evas_object_event_callback_add
1447      (sd->img, EVAS_CALLBACK_IMAGE_PRELOADED, _main_img_preloaded_cb, obj);
1448
1449    edje_object_size_min_calc(edje, &minw, &minh);
1450    evas_object_size_hint_min_set(obj, minw, minh);
1451
1452    _sizing_eval(obj);
1453
1454    //Tizen Only: This should be removed when eo is applied.
1455    ELM_WIDGET_DATA_GET(obj, wsd);
1456    wsd->on_create = EINA_FALSE;
1457
1458    return obj;
1459 }
1460
1461 EAPI Evas_Load_Error
1462 elm_photocam_file_set(Evas_Object *obj,
1463                       const char *file)
1464 {
1465    int w, h;
1466    double tz;
1467    Evas_Load_Error err;
1468
1469    ELM_PHOTOCAM_CHECK(obj) EVAS_LOAD_ERROR_NONE;
1470    ELM_PHOTOCAM_DATA_GET(obj, sd);
1471
1472    if (!eina_stringshare_replace(&sd->file, file)) return EVAS_LOAD_ERROR_NONE;
1473    _grid_clear_all(obj);
1474
1475    evas_object_hide(sd->img);
1476    evas_object_image_smooth_scale_set(sd->img, (sd->no_smooth == 0));
1477    evas_object_image_file_set(sd->img, NULL, NULL);
1478    evas_object_image_load_scale_down_set(sd->img, 0);
1479    evas_object_image_file_set(sd->img, sd->file, NULL);
1480    err = evas_object_image_load_error_get(sd->img);
1481    if (err != EVAS_LOAD_ERROR_NONE)
1482      {
1483         ERR("Things are going bad for '%s' (%p)", file, sd->img);
1484         return err;
1485      }
1486    evas_object_image_size_get(sd->img, &w, &h);
1487
1488    sd->do_region = evas_object_image_region_support_get(sd->img);
1489    sd->size.imw = w;
1490    sd->size.imh = h;
1491    sd->size.w = sd->size.imw / sd->zoom;
1492    sd->size.h = sd->size.imh / sd->zoom;
1493    if (sd->g_layer_zoom.bounce.animator)
1494      {
1495         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1496         sd->g_layer_zoom.bounce.animator = NULL;
1497      }
1498    if (sd->zoom_animator)
1499      {
1500         sd->no_smooth--;
1501         if (sd->no_smooth == 0) _smooth_update(obj);
1502         ecore_animator_del(sd->zoom_animator);
1503         sd->zoom_animator = NULL;
1504      }
1505    evas_object_image_file_set(sd->img, NULL, NULL);
1506    evas_object_image_load_scale_down_set(sd->img, 8);
1507    evas_object_image_file_set(sd->img, sd->file, NULL);
1508    err = evas_object_image_load_error_get(sd->img);
1509    if (err != EVAS_LOAD_ERROR_NONE)
1510      {
1511         ERR("Things are going bad for '%s' (%p)", file, sd->img);
1512         return err;
1513      }
1514
1515    evas_object_image_preload(sd->img, 0);
1516    sd->main_load_pending = EINA_TRUE;
1517
1518    if (sd->calc_job) ecore_job_del(sd->calc_job);
1519    sd->calc_job = ecore_job_add(_calc_job_cb, sd);
1520    evas_object_smart_callback_call(obj, SIG_LOAD, NULL);
1521    sd->preload_num++;
1522    if (sd->preload_num == 1)
1523      {
1524         edje_object_signal_emit
1525           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,state,busy,start", "elm");
1526         evas_object_smart_callback_call(obj, SIG_LOAD_DETAIL, NULL);
1527      }
1528
1529    tz = sd->zoom;
1530    sd->zoom = 0.0;
1531    elm_photocam_zoom_set(ELM_WIDGET_DATA(sd)->obj, tz);
1532
1533    return evas_object_image_load_error_get(sd->img);
1534 }
1535
1536 EAPI const char *
1537 elm_photocam_file_get(const Evas_Object *obj)
1538 {
1539    ELM_PHOTOCAM_CHECK(obj) NULL;
1540    ELM_PHOTOCAM_DATA_GET(obj, sd);
1541
1542    return sd->file;
1543 }
1544
1545 EAPI void
1546 elm_photocam_zoom_set(Evas_Object *obj,
1547                       double zoom)
1548 {
1549    double z;
1550    Eina_List *l;
1551    Ecore_Animator *an;
1552    Elm_Phocam_Grid *g, *g_zoom = NULL;
1553    Evas_Coord pw, ph, rx, ry, rw, rh;
1554    int zoom_changed = 0, started = 0;
1555
1556    ELM_PHOTOCAM_CHECK(obj);
1557    ELM_PHOTOCAM_DATA_GET(obj, sd);
1558
1559    if (zoom <= (1.0 / 256.0)) zoom = (1.0 / 256.0);
1560    if (zoom == sd->zoom) return;
1561
1562    sd->zoom = zoom;
1563    sd->size.ow = sd->size.w;
1564    sd->size.oh = sd->size.h;
1565    sd->s_iface->content_pos_get(obj, &rx, &ry);
1566    sd->s_iface->content_viewport_size_get(obj, &rw, &rh);
1567    if ((rw <= 0) || (rh <= 0)) return;
1568
1569    if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_MANUAL)
1570      {
1571         sd->size.nw = (double)sd->size.imw / sd->zoom;
1572         sd->size.nh = (double)sd->size.imh / sd->zoom;
1573      }
1574    else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT)
1575      {
1576         if ((sd->size.imw < 1) || (sd->size.imh < 1))
1577           {
1578              sd->size.nw = 0;
1579              sd->size.nh = 0;
1580           }
1581         else
1582           {
1583              ph = (sd->size.imh * rw) / sd->size.imw;
1584              if (ph > rh)
1585                {
1586                   pw = (sd->size.imw * rh) / sd->size.imh;
1587                   ph = rh;
1588                }
1589              else
1590                {
1591                   pw = rw;
1592                }
1593              if (sd->size.imw > sd->size.imh)
1594                z = (double)sd->size.imw / pw;
1595              else
1596                z = (double)sd->size.imh / ph;
1597              if (z != sd->zoom)
1598                zoom_changed = 1;
1599              sd->zoom = z;
1600              sd->size.nw = pw;
1601              sd->size.nh = ph;
1602           }
1603      }
1604    else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FILL)
1605      {
1606         if ((sd->size.imw < 1) || (sd->size.imh < 1))
1607           {
1608              sd->size.nw = 0;
1609              sd->size.nw = 0;
1610           }
1611         else
1612           {
1613              ph = (sd->size.imh * rw) / sd->size.imw;
1614              if (ph < rh)
1615                {
1616                   pw = (sd->size.imw * rh) / sd->size.imh;
1617                   ph = rh;
1618                }
1619              else
1620                {
1621                   pw = rw;
1622                }
1623              if (sd->size.imw > sd->size.imh)
1624                z = (double)sd->size.imw / pw;
1625              else
1626                z = (double)sd->size.imh / ph;
1627              if (z != sd->zoom)
1628                zoom_changed = 1;
1629              sd->zoom = z;
1630              sd->size.nw = pw;
1631              sd->size.nh = ph;
1632           }
1633      }
1634    else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT_IN)
1635      {
1636         if ((sd->size.imw < 1) || (sd->size.imh < 1))
1637           {
1638              sd->size.nw = 0;
1639              sd->size.nh = 0;
1640           }
1641         else if ((sd->size.imw < rw) && (sd->size.imh < rh))
1642           {
1643              if (1 != sd->zoom) zoom_changed = 1;
1644              sd->zoom = 1;
1645              sd->size.nw = sd->size.imw;
1646              sd->size.nh = sd->size.imh;
1647           }
1648         else
1649           {
1650              ph = (sd->size.imh * rw) / sd->size.imw;
1651              if (ph > rh)
1652                {
1653                   pw = (sd->size.imw * rh) / sd->size.imh;
1654                   ph = rh;
1655                }
1656              else
1657                pw = rw;
1658              if (sd->size.imw > sd->size.imh)
1659                z = (double)sd->size.imw / pw;
1660              else
1661                z = (double)sd->size.imh / ph;
1662              if (z != sd->zoom)
1663                zoom_changed = 1;
1664              sd->zoom = z;
1665              sd->size.nw = pw;
1666              sd->size.nh = ph;
1667           }
1668      }
1669
1670    if (sd->main_load_pending)
1671      {
1672         sd->size.w = sd->size.nw;
1673         sd->size.h = sd->size.nh;
1674
1675         goto done;
1676      }
1677
1678    EINA_LIST_FOREACH(sd->grids, l, g)
1679      {
1680         if (g->zoom == _grid_zoom_calc(sd->zoom))
1681           {
1682              sd->grids = eina_list_remove(sd->grids, g);
1683              sd->grids = eina_list_prepend(sd->grids, g);
1684              _grid_raise(g);
1685              goto done;
1686           }
1687      }
1688
1689    g = _grid_create(obj);
1690    if (g)
1691      {
1692         if (eina_list_count(sd->grids) > 1)
1693           {
1694              g_zoom = eina_list_last(sd->grids)->data;
1695              sd->grids = eina_list_remove(sd->grids, g_zoom);
1696              _grid_clear(obj, g_zoom);
1697              free(g_zoom);
1698              EINA_LIST_FOREACH(sd->grids, l, g_zoom)
1699                {
1700                   g_zoom->dead = 1;
1701                }
1702           }
1703         sd->grids = eina_list_prepend(sd->grids, g);
1704      }
1705    else
1706      {
1707         EINA_LIST_FREE (sd->grids, g)
1708           {
1709              _grid_clear(obj, g);
1710              free(g);
1711           }
1712      }
1713
1714 done:
1715    sd->t_start = ecore_loop_time_get();
1716    sd->t_end = sd->t_start + _elm_config->zoom_friction;
1717    if ((sd->size.w > 0) && (sd->size.h > 0))
1718      {
1719         sd->size.spos.x = (double)(rx + (rw / 2)) / (double)sd->size.w;
1720         sd->size.spos.y = (double)(ry + (rh / 2)) / (double)sd->size.h;
1721      }
1722    else
1723      {
1724         sd->size.spos.x = 0.5;
1725         sd->size.spos.y = 0.5;
1726      }
1727    if (rw > sd->size.w) sd->size.spos.x = 0.5;
1728    if (rh > sd->size.h) sd->size.spos.y = 0.5;
1729    if (sd->size.spos.x > 1.0) sd->size.spos.x = 1.0;
1730    if (sd->size.spos.y > 1.0) sd->size.spos.y = 1.0;
1731
1732    if (sd->paused)
1733      {
1734         _zoom_do(obj, 1.0);
1735      }
1736    else
1737      {
1738         if (!sd->zoom_animator)
1739           {
1740              sd->zoom_animator = ecore_animator_add(_zoom_anim_cb, obj);
1741              sd->no_smooth++;
1742              if (sd->no_smooth == 1) _smooth_update(obj);
1743              started = 1;
1744           }
1745      }
1746
1747    an = sd->zoom_animator;
1748    if (an)
1749      {
1750         if (!_zoom_anim_cb(obj))
1751           {
1752              ecore_animator_del(an);
1753              an = NULL;
1754           }
1755      }
1756
1757    if (sd->calc_job) ecore_job_del(sd->calc_job);
1758    sd->calc_job = ecore_job_add(_calc_job_cb, sd);
1759    if (!sd->paused)
1760      {
1761         if (started)
1762           evas_object_smart_callback_call(obj, SIG_ZOOM_START, NULL);
1763         if (!an)
1764           evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1765      }
1766    if (zoom_changed)
1767      evas_object_smart_callback_call(obj, SIG_ZOOM_CHANGE, NULL);
1768 }
1769
1770 EAPI double
1771 elm_photocam_zoom_get(const Evas_Object *obj)
1772 {
1773    ELM_PHOTOCAM_CHECK(obj) 1.0;
1774    ELM_PHOTOCAM_DATA_GET(obj, sd);
1775
1776    return sd->zoom;
1777 }
1778
1779 EAPI void
1780 elm_photocam_zoom_mode_set(Evas_Object *obj,
1781                            Elm_Photocam_Zoom_Mode mode)
1782 {
1783    double tz;
1784
1785    ELM_PHOTOCAM_CHECK(obj);
1786    ELM_PHOTOCAM_DATA_GET(obj, sd);
1787
1788    if (sd->mode == mode) return;
1789    sd->mode = mode;
1790
1791    tz = sd->zoom;
1792    sd->zoom = 0.0;
1793    elm_photocam_zoom_set(ELM_WIDGET_DATA(sd)->obj, tz);
1794 }
1795
1796 EAPI Elm_Photocam_Zoom_Mode
1797 elm_photocam_zoom_mode_get(const Evas_Object *obj)
1798 {
1799    ELM_PHOTOCAM_CHECK(obj) ELM_PHOTOCAM_ZOOM_MODE_LAST;
1800    ELM_PHOTOCAM_DATA_GET(obj, sd);
1801
1802    return sd->mode;
1803 }
1804
1805 EAPI void
1806 elm_photocam_image_size_get(const Evas_Object *obj,
1807                             int *w,
1808                             int *h)
1809 {
1810    ELM_PHOTOCAM_CHECK(obj);
1811    ELM_PHOTOCAM_DATA_GET(obj, sd);
1812
1813    if (w) *w = sd->size.imw;
1814    if (h) *h = sd->size.imh;
1815 }
1816
1817 EAPI void
1818 elm_photocam_image_region_get(const Evas_Object *obj,
1819                               int *x,
1820                               int *y,
1821                               int *w,
1822                               int *h)
1823 {
1824    Evas_Coord sx, sy, sw, sh;
1825
1826    ELM_PHOTOCAM_CHECK(obj);
1827    ELM_PHOTOCAM_DATA_GET(obj, sd);
1828
1829    sd->s_iface->content_pos_get(obj, &sx, &sy);
1830    sd->s_iface->content_viewport_size_get(obj, &sw, &sh);
1831    if (sd->size.w > 0)
1832      {
1833         if (x)
1834           {
1835              *x = (sd->size.imw * sx) / sd->size.w;
1836              if (*x > sd->size.imw) *x = sd->size.imw;
1837           }
1838         if (w)
1839           {
1840              *w = (sd->size.imw * sw) / sd->size.w;
1841              if (*w > sd->size.imw) *w = sd->size.imw;
1842              else if (*w < 0)
1843                *w = 0;
1844           }
1845      }
1846    else
1847      {
1848         if (x) *x = 0;
1849         if (w) *w = 0;
1850      }
1851
1852    if (sd->size.h > 0)
1853      {
1854         if (y)
1855           {
1856              *y = (sd->size.imh * sy) / sd->size.h;
1857              if (*y > sd->size.imh) *y = sd->size.imh;
1858           }
1859         if (h)
1860           {
1861              *h = (sd->size.imh * sh) / sd->size.h;
1862              if (*h > sd->size.imh) *h = sd->size.imh;
1863              else if (*h < 0)
1864                *h = 0;
1865           }
1866      }
1867    else
1868      {
1869         if (y) *y = 0;
1870         if (h) *h = 0;
1871      }
1872 }
1873
1874 EAPI void
1875 elm_photocam_image_region_show(Evas_Object *obj,
1876                                int x,
1877                                int y,
1878                                int w,
1879                                int h __UNUSED__)
1880 {
1881    int rx, ry, rw, rh;
1882
1883    ELM_PHOTOCAM_CHECK(obj);
1884    ELM_PHOTOCAM_DATA_GET(obj, sd);
1885
1886    if ((sd->size.imw < 1) || (sd->size.imh < 1)) return;
1887    rx = (x * sd->size.w) / sd->size.imw;
1888    ry = (y * sd->size.h) / sd->size.imh;
1889    rw = (w * sd->size.w) / sd->size.imw;
1890    rh = (h * sd->size.h) / sd->size.imh;
1891    if (rw < 1) rw = 1;
1892    if (rh < 1) rh = 1;
1893    if ((rx + rw) > sd->size.w) rx = sd->size.w - rw;
1894    if ((ry + rh) > sd->size.h) ry = sd->size.h - rh;
1895    if (sd->g_layer_zoom.bounce.animator)
1896      {
1897         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1898         sd->g_layer_zoom.bounce.animator = NULL;
1899         _zoom_do(obj, 1.0);
1900      }
1901    if (sd->zoom_animator)
1902      {
1903         sd->no_smooth--;
1904         ecore_animator_del(sd->zoom_animator);
1905         sd->zoom_animator = NULL;
1906         _zoom_do(obj, 1.0);
1907         evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1908      }
1909    sd->s_iface->content_region_show(obj, rx, ry, rw, rh);
1910 }
1911
1912 EAPI void
1913 elm_photocam_image_region_bring_in(Evas_Object *obj,
1914                                    int x,
1915                                    int y,
1916                                    int w,
1917                                    int h __UNUSED__)
1918 {
1919    int rx, ry, rw, rh;
1920
1921    ELM_PHOTOCAM_CHECK(obj);
1922    ELM_PHOTOCAM_DATA_GET(obj, sd);
1923
1924    if ((sd->size.imw < 1) || (sd->size.imh < 1)) return;
1925    rx = (x * sd->size.w) / sd->size.imw;
1926    ry = (y * sd->size.h) / sd->size.imh;
1927    rw = (w * sd->size.w) / sd->size.imw;
1928    rh = (h * sd->size.h) / sd->size.imh;
1929    if (rw < 1) rw = 1;
1930    if (rh < 1) rh = 1;
1931    if ((rx + rw) > sd->size.w) rx = sd->size.w - rw;
1932    if ((ry + rh) > sd->size.h) ry = sd->size.h - rh;
1933    if (sd->g_layer_zoom.bounce.animator)
1934      {
1935         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1936         sd->g_layer_zoom.bounce.animator = NULL;
1937         _zoom_do(obj, 1.0);
1938      }
1939    if (sd->zoom_animator)
1940      {
1941         sd->no_smooth--;
1942         if (!sd->no_smooth) _smooth_update(obj);
1943         ecore_animator_del(sd->zoom_animator);
1944         sd->zoom_animator = NULL;
1945         _zoom_do(obj, 1.0);
1946         evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1947      }
1948    sd->s_iface->region_bring_in(obj, rx, ry, rw, rh);
1949 }
1950
1951 EAPI void
1952 elm_photocam_paused_set(Evas_Object *obj,
1953                         Eina_Bool paused)
1954 {
1955    ELM_PHOTOCAM_CHECK(obj);
1956    ELM_PHOTOCAM_DATA_GET(obj, sd);
1957
1958    paused = !!paused;
1959
1960    if (sd->paused == paused) return;
1961    sd->paused = paused;
1962    if (!sd->paused) return;
1963
1964    if (sd->g_layer_zoom.bounce.animator)
1965      {
1966         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1967         sd->g_layer_zoom.bounce.animator = NULL;
1968         _zoom_do(obj, 1.0);
1969      }
1970    if (sd->zoom_animator)
1971      {
1972         ecore_animator_del(sd->zoom_animator);
1973         sd->zoom_animator = NULL;
1974         _zoom_do(obj, 1.0);
1975         evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1976      }
1977 }
1978
1979 EAPI Eina_Bool
1980 elm_photocam_paused_get(const Evas_Object *obj)
1981 {
1982    ELM_PHOTOCAM_CHECK(obj) EINA_FALSE;
1983    ELM_PHOTOCAM_DATA_GET(obj, sd);
1984
1985    return sd->paused;
1986 }
1987
1988 EAPI Evas_Object *
1989 elm_photocam_internal_image_get(const Evas_Object *obj)
1990 {
1991    ELM_PHOTOCAM_CHECK(obj) NULL;
1992    ELM_PHOTOCAM_DATA_GET(obj, sd);
1993
1994    return sd->img;
1995 }
1996
1997 EAPI void
1998 elm_photocam_bounce_set(Evas_Object *obj,
1999                         Eina_Bool h_bounce,
2000                         Eina_Bool v_bounce)
2001 {
2002    ELM_PHOTOCAM_CHECK(obj);
2003    ELM_PHOTOCAM_DATA_GET(obj, sd);
2004
2005    sd->s_iface->bounce_allow_set(obj, h_bounce, v_bounce);
2006 }
2007
2008 EAPI void
2009 elm_photocam_bounce_get(const Evas_Object *obj,
2010                         Eina_Bool *h_bounce,
2011                         Eina_Bool *v_bounce)
2012 {
2013    ELM_PHOTOCAM_CHECK(obj);
2014    ELM_PHOTOCAM_DATA_GET(obj, sd);
2015
2016    sd->s_iface->bounce_allow_get(obj, h_bounce, v_bounce);
2017 }
2018
2019 EAPI void
2020 elm_photocam_gesture_enabled_set(Evas_Object *obj,
2021                                  Eina_Bool gesture)
2022 {
2023    ELM_PHOTOCAM_CHECK(obj);
2024    ELM_PHOTOCAM_DATA_GET(obj, sd);
2025
2026    gesture = !!gesture;
2027
2028    if (sd->do_gesture == gesture) return;
2029
2030    sd->do_gesture = gesture;
2031
2032    if (sd->g_layer)
2033      {
2034         evas_object_del(sd->g_layer);
2035         sd->g_layer = NULL;
2036      }
2037
2038    if (!gesture) return;
2039
2040    sd->g_layer = elm_gesture_layer_add(obj);
2041    if (!sd->g_layer) return;
2042
2043    elm_gesture_layer_attach(sd->g_layer, obj);
2044    elm_gesture_layer_cb_set
2045      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START,
2046      _g_layer_zoom_start_cb, sd);
2047    elm_gesture_layer_cb_set
2048      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE,
2049      _g_layer_zoom_move_cb, sd);
2050    elm_gesture_layer_cb_set
2051      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_END,
2052      _g_layer_zoom_end_cb, sd);
2053    elm_gesture_layer_cb_set
2054      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_ABORT,
2055      _g_layer_zoom_end_cb, sd);
2056 }
2057
2058 EAPI Eina_Bool
2059 elm_photocam_gesture_enabled_get(const Evas_Object *obj)
2060 {
2061    ELM_PHOTOCAM_CHECK(obj) EINA_FALSE;
2062    ELM_PHOTOCAM_DATA_GET(obj, sd);
2063
2064    return sd->do_gesture;
2065 }