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_Coord minw, minh;
1274    Elm_Photocam_Pan_Smart_Data *pan_data;
1275    Eina_Bool bounce = _elm_config->thumbscroll_bounce_enable;
1276
1277    EVAS_SMART_DATA_ALLOC(obj, Elm_Photocam_Smart_Data);
1278
1279    ELM_WIDGET_DATA(priv)->resize_obj =
1280      edje_object_add(evas_object_evas_get(obj));
1281
1282    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.add(obj);
1283
1284    elm_widget_theme_object_set
1285      (obj, ELM_WIDGET_DATA(priv)->resize_obj, "photocam", "base",
1286      elm_widget_style_get(obj));
1287
1288    priv->hit_rect = evas_object_rectangle_add(evas_object_evas_get(obj));
1289    evas_object_smart_member_add(priv->hit_rect, obj);
1290    elm_widget_sub_object_add(obj, priv->hit_rect);
1291
1292    /* common scroller hit rectangle setup */
1293    evas_object_color_set(priv->hit_rect, 0, 0, 0, 0);
1294    evas_object_show(priv->hit_rect);
1295    evas_object_repeat_events_set(priv->hit_rect, EINA_TRUE);
1296
1297    elm_widget_can_focus_set(obj, EINA_TRUE);
1298
1299    priv->s_iface = evas_object_smart_interface_get
1300        (obj, ELM_SCROLLABLE_IFACE_NAME);
1301
1302    priv->s_iface->objects_set
1303      (obj, ELM_WIDGET_DATA(priv)->resize_obj, priv->hit_rect);
1304
1305    priv->s_iface->animate_start_cb_set(obj, _scroll_animate_start_cb);
1306    priv->s_iface->animate_stop_cb_set(obj, _scroll_animate_stop_cb);
1307    priv->s_iface->drag_start_cb_set(obj, _scroll_drag_start_cb);
1308    priv->s_iface->drag_stop_cb_set(obj, _scroll_drag_stop_cb);
1309    priv->s_iface->scroll_cb_set(obj, _scroll_cb);
1310
1311    priv->s_iface->bounce_allow_set(obj, bounce, bounce);
1312
1313    priv->pan_obj = evas_object_smart_add
1314        (evas_object_evas_get(obj), _elm_photocam_pan_smart_class_new());
1315    pan_data = evas_object_smart_data_get(priv->pan_obj);
1316    pan_data->wsd = priv;
1317
1318    priv->s_iface->extern_pan_set(obj, priv->pan_obj);
1319
1320    priv->zoom_g_layer = EINA_FALSE;
1321    priv->g_layer_start = 1.0;
1322    priv->zoom = 1;
1323    priv->mode = ELM_PHOTOCAM_ZOOM_MODE_MANUAL;
1324    priv->tsize = 512;
1325
1326    priv->img = evas_object_image_add(evas_object_evas_get(obj));
1327    evas_object_image_load_orientation_set(priv->img, EINA_TRUE);
1328    evas_object_image_scale_hint_set(priv->img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
1329    evas_object_event_callback_add
1330      (priv->img, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, obj);
1331    evas_object_event_callback_add
1332      (priv->img, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, obj);
1333    evas_object_image_scale_hint_set(priv->img, EVAS_IMAGE_SCALE_HINT_STATIC);
1334
1335    /* XXX: mmm... */
1336    evas_object_smart_member_add(priv->img, priv->pan_obj);
1337
1338    elm_widget_sub_object_add(obj, priv->img);
1339    evas_object_image_filled_set(priv->img, EINA_TRUE);
1340    evas_object_event_callback_add
1341      (priv->img, EVAS_CALLBACK_IMAGE_PRELOADED, _main_img_preloaded_cb, obj);
1342
1343    edje_object_size_min_calc(ELM_WIDGET_DATA(priv)->resize_obj, &minw, &minh);
1344    evas_object_size_hint_min_set(obj, minw, minh);
1345
1346    _sizing_eval(obj);
1347
1348 }
1349
1350 static void
1351 _elm_photocam_smart_del(Evas_Object *obj)
1352 {
1353    Elm_Phocam_Grid *g;
1354
1355    ELM_PHOTOCAM_DATA_GET(obj, sd);
1356
1357    EINA_LIST_FREE (sd->grids, g)
1358      {
1359         if (g->grid) free(g->grid);
1360         free(g);
1361      }
1362    evas_object_del(sd->pan_obj);
1363    sd->pan_obj = NULL;
1364
1365    if (sd->file) eina_stringshare_del(sd->file);
1366    if (sd->calc_job) ecore_job_del(sd->calc_job);
1367    if (sd->scr_timer) ecore_timer_del(sd->scr_timer);
1368    if (sd->zoom_animator) ecore_animator_del(sd->zoom_animator);
1369    if (sd->g_layer_zoom.bounce.animator)
1370      ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1371    if (sd->long_timer) ecore_timer_del(sd->long_timer);
1372
1373    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.del(obj);
1374 }
1375
1376 static void
1377 _elm_photocam_smart_move(Evas_Object *obj,
1378                          Evas_Coord x,
1379                          Evas_Coord y)
1380 {
1381    ELM_PHOTOCAM_DATA_GET(obj, sd);
1382
1383    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.move(obj, x, y);
1384
1385    evas_object_move(sd->hit_rect, x, y);
1386 }
1387
1388 static void
1389 _elm_photocam_smart_resize(Evas_Object *obj,
1390                            Evas_Coord w,
1391                            Evas_Coord h)
1392 {
1393    ELM_PHOTOCAM_DATA_GET(obj, sd);
1394
1395    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.resize(obj, w, h);
1396
1397    evas_object_resize(sd->hit_rect, w, h);
1398 }
1399
1400 static void
1401 _elm_photocam_smart_member_add(Evas_Object *obj,
1402                                Evas_Object *member)
1403 {
1404    ELM_PHOTOCAM_DATA_GET(obj, sd);
1405
1406    ELM_WIDGET_CLASS(_elm_photocam_parent_sc)->base.member_add(obj, member);
1407
1408    if (sd->hit_rect)
1409      evas_object_raise(sd->hit_rect);
1410 }
1411
1412 static void
1413 _elm_photocam_smart_set_user(Elm_Photocam_Smart_Class *sc)
1414 {
1415    ELM_WIDGET_CLASS(sc)->base.add = _elm_photocam_smart_add;
1416    ELM_WIDGET_CLASS(sc)->base.del = _elm_photocam_smart_del;
1417    ELM_WIDGET_CLASS(sc)->base.move = _elm_photocam_smart_move;
1418    ELM_WIDGET_CLASS(sc)->base.resize = _elm_photocam_smart_resize;
1419    ELM_WIDGET_CLASS(sc)->base.member_add = _elm_photocam_smart_member_add;
1420
1421    ELM_WIDGET_CLASS(sc)->on_focus = _elm_photocam_smart_on_focus;
1422    ELM_WIDGET_CLASS(sc)->theme = _elm_photocam_smart_theme;
1423    ELM_WIDGET_CLASS(sc)->event = _elm_photocam_smart_event;
1424 }
1425
1426 EAPI const Elm_Photocam_Smart_Class *
1427 elm_photocam_smart_class_get(void)
1428 {
1429    static Elm_Photocam_Smart_Class _sc =
1430      ELM_PHOTOCAM_SMART_CLASS_INIT_NAME_VERSION(ELM_PHOTOCAM_SMART_NAME);
1431    static const Elm_Photocam_Smart_Class *class = NULL;
1432    Evas_Smart_Class *esc = (Evas_Smart_Class *)&_sc;
1433
1434    if (class) return class;
1435
1436    _elm_photocam_smart_set(&_sc);
1437    esc->callbacks = _smart_callbacks;
1438    class = &_sc;
1439
1440    return class;
1441 }
1442
1443 EAPI Evas_Object *
1444 elm_photocam_add(Evas_Object *parent)
1445 {
1446    Evas_Object *obj;
1447
1448    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
1449
1450    obj = elm_widget_add(_elm_photocam_smart_class_new(), parent);
1451    if (!obj) return NULL;
1452
1453    if (!elm_widget_sub_object_add(parent, obj))
1454      ERR("could not add %p as sub object of %p", obj, parent);
1455
1456    return obj;
1457 }
1458
1459 EAPI Evas_Load_Error
1460 elm_photocam_file_set(Evas_Object *obj,
1461                       const char *file)
1462 {
1463    int w, h;
1464    double tz;
1465    Evas_Load_Error err;
1466
1467    ELM_PHOTOCAM_CHECK(obj) EVAS_LOAD_ERROR_NONE;
1468    ELM_PHOTOCAM_DATA_GET(obj, sd);
1469
1470    if (!eina_stringshare_replace(&sd->file, file)) return EVAS_LOAD_ERROR_NONE;
1471    _grid_clear_all(obj);
1472
1473    evas_object_hide(sd->img);
1474    evas_object_image_smooth_scale_set(sd->img, (sd->no_smooth == 0));
1475    evas_object_image_file_set(sd->img, NULL, NULL);
1476    evas_object_image_load_scale_down_set(sd->img, 0);
1477    evas_object_image_file_set(sd->img, sd->file, NULL);
1478    err = evas_object_image_load_error_get(sd->img);
1479    if (err != EVAS_LOAD_ERROR_NONE)
1480      {
1481         ERR("Things are going bad for '%s' (%p)", file, sd->img);
1482         return err;
1483      }
1484    evas_object_image_size_get(sd->img, &w, &h);
1485
1486    sd->do_region = evas_object_image_region_support_get(sd->img);
1487    sd->size.imw = w;
1488    sd->size.imh = h;
1489    sd->size.w = sd->size.imw / sd->zoom;
1490    sd->size.h = sd->size.imh / sd->zoom;
1491    if (sd->g_layer_zoom.bounce.animator)
1492      {
1493         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1494         sd->g_layer_zoom.bounce.animator = NULL;
1495      }
1496    if (sd->zoom_animator)
1497      {
1498         sd->no_smooth--;
1499         if (sd->no_smooth == 0) _smooth_update(obj);
1500         ecore_animator_del(sd->zoom_animator);
1501         sd->zoom_animator = NULL;
1502      }
1503    evas_object_image_file_set(sd->img, NULL, NULL);
1504    evas_object_image_load_scale_down_set(sd->img, 8);
1505    evas_object_image_file_set(sd->img, sd->file, NULL);
1506    err = evas_object_image_load_error_get(sd->img);
1507    if (err != EVAS_LOAD_ERROR_NONE)
1508      {
1509         ERR("Things are going bad for '%s' (%p)", file, sd->img);
1510         return err;
1511      }
1512
1513    evas_object_image_preload(sd->img, 0);
1514    sd->main_load_pending = EINA_TRUE;
1515
1516    if (sd->calc_job) ecore_job_del(sd->calc_job);
1517    sd->calc_job = ecore_job_add(_calc_job_cb, sd);
1518    evas_object_smart_callback_call(obj, SIG_LOAD, NULL);
1519    sd->preload_num++;
1520    if (sd->preload_num == 1)
1521      {
1522         edje_object_signal_emit
1523           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,state,busy,start", "elm");
1524         evas_object_smart_callback_call(obj, SIG_LOAD_DETAIL, NULL);
1525      }
1526
1527    tz = sd->zoom;
1528    sd->zoom = 0.0;
1529    elm_photocam_zoom_set(ELM_WIDGET_DATA(sd)->obj, tz);
1530
1531    return evas_object_image_load_error_get(sd->img);
1532 }
1533
1534 EAPI const char *
1535 elm_photocam_file_get(const Evas_Object *obj)
1536 {
1537    ELM_PHOTOCAM_CHECK(obj) NULL;
1538    ELM_PHOTOCAM_DATA_GET(obj, sd);
1539
1540    return sd->file;
1541 }
1542
1543 EAPI void
1544 elm_photocam_zoom_set(Evas_Object *obj,
1545                       double zoom)
1546 {
1547    double z;
1548    Eina_List *l;
1549    Ecore_Animator *an;
1550    Elm_Phocam_Grid *g, *g_zoom = NULL;
1551    Evas_Coord pw, ph, rx, ry, rw, rh;
1552    int zoom_changed = 0, started = 0;
1553
1554    ELM_PHOTOCAM_CHECK(obj);
1555    ELM_PHOTOCAM_DATA_GET(obj, sd);
1556
1557    if (zoom <= (1.0 / 256.0)) zoom = (1.0 / 256.0);
1558    if (zoom == sd->zoom) return;
1559
1560    sd->zoom = zoom;
1561    sd->size.ow = sd->size.w;
1562    sd->size.oh = sd->size.h;
1563    sd->s_iface->content_pos_get(obj, &rx, &ry);
1564    sd->s_iface->content_viewport_size_get(obj, &rw, &rh);
1565    if ((rw <= 0) || (rh <= 0)) return;
1566
1567    if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_MANUAL)
1568      {
1569         sd->size.nw = (double)sd->size.imw / sd->zoom;
1570         sd->size.nh = (double)sd->size.imh / sd->zoom;
1571      }
1572    else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT)
1573      {
1574         if ((sd->size.imw < 1) || (sd->size.imh < 1))
1575           {
1576              sd->size.nw = 0;
1577              sd->size.nh = 0;
1578           }
1579         else
1580           {
1581              ph = (sd->size.imh * rw) / sd->size.imw;
1582              if (ph > rh)
1583                {
1584                   pw = (sd->size.imw * rh) / sd->size.imh;
1585                   ph = rh;
1586                }
1587              else
1588                {
1589                   pw = rw;
1590                }
1591              if (sd->size.imw > sd->size.imh)
1592                z = (double)sd->size.imw / pw;
1593              else
1594                z = (double)sd->size.imh / ph;
1595              if (z != sd->zoom)
1596                zoom_changed = 1;
1597              sd->zoom = z;
1598              sd->size.nw = pw;
1599              sd->size.nh = ph;
1600           }
1601      }
1602    else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FILL)
1603      {
1604         if ((sd->size.imw < 1) || (sd->size.imh < 1))
1605           {
1606              sd->size.nw = 0;
1607              sd->size.nw = 0;
1608           }
1609         else
1610           {
1611              ph = (sd->size.imh * rw) / sd->size.imw;
1612              if (ph < rh)
1613                {
1614                   pw = (sd->size.imw * rh) / sd->size.imh;
1615                   ph = rh;
1616                }
1617              else
1618                {
1619                   pw = rw;
1620                }
1621              if (sd->size.imw > sd->size.imh)
1622                z = (double)sd->size.imw / pw;
1623              else
1624                z = (double)sd->size.imh / ph;
1625              if (z != sd->zoom)
1626                zoom_changed = 1;
1627              sd->zoom = z;
1628              sd->size.nw = pw;
1629              sd->size.nh = ph;
1630           }
1631      }
1632    else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT_IN)
1633      {
1634         if ((sd->size.imw < 1) || (sd->size.imh < 1))
1635           {
1636              sd->size.nw = 0;
1637              sd->size.nh = 0;
1638           }
1639         else if ((sd->size.imw < rw) && (sd->size.imh < rh))
1640           {
1641              if (1 != sd->zoom) zoom_changed = 1;
1642              sd->zoom = 1;
1643              sd->size.nw = sd->size.imw;
1644              sd->size.nh = sd->size.imh;
1645           }
1646         else
1647           {
1648              ph = (sd->size.imh * rw) / sd->size.imw;
1649              if (ph > rh)
1650                {
1651                   pw = (sd->size.imw * rh) / sd->size.imh;
1652                   ph = rh;
1653                }
1654              else
1655                pw = rw;
1656              if (sd->size.imw > sd->size.imh)
1657                z = (double)sd->size.imw / pw;
1658              else
1659                z = (double)sd->size.imh / ph;
1660              if (z != sd->zoom)
1661                zoom_changed = 1;
1662              sd->zoom = z;
1663              sd->size.nw = pw;
1664              sd->size.nh = ph;
1665           }
1666      }
1667
1668    if (sd->main_load_pending)
1669      {
1670         sd->size.w = sd->size.nw;
1671         sd->size.h = sd->size.nh;
1672
1673         goto done;
1674      }
1675
1676    EINA_LIST_FOREACH(sd->grids, l, g)
1677      {
1678         if (g->zoom == _grid_zoom_calc(sd->zoom))
1679           {
1680              sd->grids = eina_list_remove(sd->grids, g);
1681              sd->grids = eina_list_prepend(sd->grids, g);
1682              _grid_raise(g);
1683              goto done;
1684           }
1685      }
1686
1687    g = _grid_create(obj);
1688    if (g)
1689      {
1690         if (eina_list_count(sd->grids) > 1)
1691           {
1692              g_zoom = eina_list_last(sd->grids)->data;
1693              sd->grids = eina_list_remove(sd->grids, g_zoom);
1694              _grid_clear(obj, g_zoom);
1695              free(g_zoom);
1696              EINA_LIST_FOREACH(sd->grids, l, g_zoom)
1697                {
1698                   g_zoom->dead = 1;
1699                }
1700           }
1701         sd->grids = eina_list_prepend(sd->grids, g);
1702      }
1703    else
1704      {
1705         EINA_LIST_FREE (sd->grids, g)
1706           {
1707              _grid_clear(obj, g);
1708              free(g);
1709           }
1710      }
1711
1712 done:
1713    sd->t_start = ecore_loop_time_get();
1714    sd->t_end = sd->t_start + _elm_config->zoom_friction;
1715    if ((sd->size.w > 0) && (sd->size.h > 0))
1716      {
1717         sd->size.spos.x = (double)(rx + (rw / 2)) / (double)sd->size.w;
1718         sd->size.spos.y = (double)(ry + (rh / 2)) / (double)sd->size.h;
1719      }
1720    else
1721      {
1722         sd->size.spos.x = 0.5;
1723         sd->size.spos.y = 0.5;
1724      }
1725    if (rw > sd->size.w) sd->size.spos.x = 0.5;
1726    if (rh > sd->size.h) sd->size.spos.y = 0.5;
1727    if (sd->size.spos.x > 1.0) sd->size.spos.x = 1.0;
1728    if (sd->size.spos.y > 1.0) sd->size.spos.y = 1.0;
1729
1730    if (sd->paused)
1731      {
1732         _zoom_do(obj, 1.0);
1733      }
1734    else
1735      {
1736         if (!sd->zoom_animator)
1737           {
1738              sd->zoom_animator = ecore_animator_add(_zoom_anim_cb, obj);
1739              sd->no_smooth++;
1740              if (sd->no_smooth == 1) _smooth_update(obj);
1741              started = 1;
1742           }
1743      }
1744
1745    an = sd->zoom_animator;
1746    if (an)
1747      {
1748         if (!_zoom_anim_cb(obj))
1749           {
1750              ecore_animator_del(an);
1751              an = NULL;
1752           }
1753      }
1754
1755    if (sd->calc_job) ecore_job_del(sd->calc_job);
1756    sd->calc_job = ecore_job_add(_calc_job_cb, sd);
1757    if (!sd->paused)
1758      {
1759         if (started)
1760           evas_object_smart_callback_call(obj, SIG_ZOOM_START, NULL);
1761         if (!an)
1762           evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1763      }
1764    if (zoom_changed)
1765      evas_object_smart_callback_call(obj, SIG_ZOOM_CHANGE, NULL);
1766 }
1767
1768 EAPI double
1769 elm_photocam_zoom_get(const Evas_Object *obj)
1770 {
1771    ELM_PHOTOCAM_CHECK(obj) 1.0;
1772    ELM_PHOTOCAM_DATA_GET(obj, sd);
1773
1774    return sd->zoom;
1775 }
1776
1777 EAPI void
1778 elm_photocam_zoom_mode_set(Evas_Object *obj,
1779                            Elm_Photocam_Zoom_Mode mode)
1780 {
1781    double tz;
1782
1783    ELM_PHOTOCAM_CHECK(obj);
1784    ELM_PHOTOCAM_DATA_GET(obj, sd);
1785
1786    if (sd->mode == mode) return;
1787    sd->mode = mode;
1788
1789    tz = sd->zoom;
1790    sd->zoom = 0.0;
1791    elm_photocam_zoom_set(ELM_WIDGET_DATA(sd)->obj, tz);
1792 }
1793
1794 EAPI Elm_Photocam_Zoom_Mode
1795 elm_photocam_zoom_mode_get(const Evas_Object *obj)
1796 {
1797    ELM_PHOTOCAM_CHECK(obj) ELM_PHOTOCAM_ZOOM_MODE_LAST;
1798    ELM_PHOTOCAM_DATA_GET(obj, sd);
1799
1800    return sd->mode;
1801 }
1802
1803 EAPI void
1804 elm_photocam_image_size_get(const Evas_Object *obj,
1805                             int *w,
1806                             int *h)
1807 {
1808    ELM_PHOTOCAM_CHECK(obj);
1809    ELM_PHOTOCAM_DATA_GET(obj, sd);
1810
1811    if (w) *w = sd->size.imw;
1812    if (h) *h = sd->size.imh;
1813 }
1814
1815 EAPI void
1816 elm_photocam_image_region_get(const Evas_Object *obj,
1817                               int *x,
1818                               int *y,
1819                               int *w,
1820                               int *h)
1821 {
1822    Evas_Coord sx, sy, sw, sh;
1823
1824    ELM_PHOTOCAM_CHECK(obj);
1825    ELM_PHOTOCAM_DATA_GET(obj, sd);
1826
1827    sd->s_iface->content_pos_get(obj, &sx, &sy);
1828    sd->s_iface->content_viewport_size_get(obj, &sw, &sh);
1829    if (sd->size.w > 0)
1830      {
1831         if (x)
1832           {
1833              *x = (sd->size.imw * sx) / sd->size.w;
1834              if (*x > sd->size.imw) *x = sd->size.imw;
1835           }
1836         if (w)
1837           {
1838              *w = (sd->size.imw * sw) / sd->size.w;
1839              if (*w > sd->size.imw) *w = sd->size.imw;
1840              else if (*w < 0)
1841                *w = 0;
1842           }
1843      }
1844    else
1845      {
1846         if (x) *x = 0;
1847         if (w) *w = 0;
1848      }
1849
1850    if (sd->size.h > 0)
1851      {
1852         if (y)
1853           {
1854              *y = (sd->size.imh * sy) / sd->size.h;
1855              if (*y > sd->size.imh) *y = sd->size.imh;
1856           }
1857         if (h)
1858           {
1859              *h = (sd->size.imh * sh) / sd->size.h;
1860              if (*h > sd->size.imh) *h = sd->size.imh;
1861              else if (*h < 0)
1862                *h = 0;
1863           }
1864      }
1865    else
1866      {
1867         if (y) *y = 0;
1868         if (h) *h = 0;
1869      }
1870 }
1871
1872 EAPI void
1873 elm_photocam_image_region_show(Evas_Object *obj,
1874                                int x,
1875                                int y,
1876                                int w,
1877                                int h __UNUSED__)
1878 {
1879    int rx, ry, rw, rh;
1880
1881    ELM_PHOTOCAM_CHECK(obj);
1882    ELM_PHOTOCAM_DATA_GET(obj, sd);
1883
1884    if ((sd->size.imw < 1) || (sd->size.imh < 1)) return;
1885    rx = (x * sd->size.w) / sd->size.imw;
1886    ry = (y * sd->size.h) / sd->size.imh;
1887    rw = (w * sd->size.w) / sd->size.imw;
1888    rh = (h * sd->size.h) / sd->size.imh;
1889    if (rw < 1) rw = 1;
1890    if (rh < 1) rh = 1;
1891    if ((rx + rw) > sd->size.w) rx = sd->size.w - rw;
1892    if ((ry + rh) > sd->size.h) ry = sd->size.h - rh;
1893    if (sd->g_layer_zoom.bounce.animator)
1894      {
1895         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1896         sd->g_layer_zoom.bounce.animator = NULL;
1897         _zoom_do(obj, 1.0);
1898      }
1899    if (sd->zoom_animator)
1900      {
1901         sd->no_smooth--;
1902         ecore_animator_del(sd->zoom_animator);
1903         sd->zoom_animator = NULL;
1904         _zoom_do(obj, 1.0);
1905         evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1906      }
1907    sd->s_iface->content_region_show(obj, rx, ry, rw, rh);
1908 }
1909
1910 EAPI void
1911 elm_photocam_image_region_bring_in(Evas_Object *obj,
1912                                    int x,
1913                                    int y,
1914                                    int w,
1915                                    int h __UNUSED__)
1916 {
1917    int rx, ry, rw, rh;
1918
1919    ELM_PHOTOCAM_CHECK(obj);
1920    ELM_PHOTOCAM_DATA_GET(obj, sd);
1921
1922    if ((sd->size.imw < 1) || (sd->size.imh < 1)) return;
1923    rx = (x * sd->size.w) / sd->size.imw;
1924    ry = (y * sd->size.h) / sd->size.imh;
1925    rw = (w * sd->size.w) / sd->size.imw;
1926    rh = (h * sd->size.h) / sd->size.imh;
1927    if (rw < 1) rw = 1;
1928    if (rh < 1) rh = 1;
1929    if ((rx + rw) > sd->size.w) rx = sd->size.w - rw;
1930    if ((ry + rh) > sd->size.h) ry = sd->size.h - rh;
1931    if (sd->g_layer_zoom.bounce.animator)
1932      {
1933         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1934         sd->g_layer_zoom.bounce.animator = NULL;
1935         _zoom_do(obj, 1.0);
1936      }
1937    if (sd->zoom_animator)
1938      {
1939         sd->no_smooth--;
1940         if (!sd->no_smooth) _smooth_update(obj);
1941         ecore_animator_del(sd->zoom_animator);
1942         sd->zoom_animator = NULL;
1943         _zoom_do(obj, 1.0);
1944         evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1945      }
1946    sd->s_iface->region_bring_in(obj, rx, ry, rw, rh);
1947 }
1948
1949 EAPI void
1950 elm_photocam_paused_set(Evas_Object *obj,
1951                         Eina_Bool paused)
1952 {
1953    ELM_PHOTOCAM_CHECK(obj);
1954    ELM_PHOTOCAM_DATA_GET(obj, sd);
1955
1956    paused = !!paused;
1957
1958    if (sd->paused == paused) return;
1959    sd->paused = paused;
1960    if (!sd->paused) return;
1961
1962    if (sd->g_layer_zoom.bounce.animator)
1963      {
1964         ecore_animator_del(sd->g_layer_zoom.bounce.animator);
1965         sd->g_layer_zoom.bounce.animator = NULL;
1966         _zoom_do(obj, 1.0);
1967      }
1968    if (sd->zoom_animator)
1969      {
1970         ecore_animator_del(sd->zoom_animator);
1971         sd->zoom_animator = NULL;
1972         _zoom_do(obj, 1.0);
1973         evas_object_smart_callback_call(obj, SIG_ZOOM_STOP, NULL);
1974      }
1975 }
1976
1977 EAPI Eina_Bool
1978 elm_photocam_paused_get(const Evas_Object *obj)
1979 {
1980    ELM_PHOTOCAM_CHECK(obj) EINA_FALSE;
1981    ELM_PHOTOCAM_DATA_GET(obj, sd);
1982
1983    return sd->paused;
1984 }
1985
1986 EAPI Evas_Object *
1987 elm_photocam_internal_image_get(const Evas_Object *obj)
1988 {
1989    ELM_PHOTOCAM_CHECK(obj) NULL;
1990    ELM_PHOTOCAM_DATA_GET(obj, sd);
1991
1992    return sd->img;
1993 }
1994
1995 EAPI void
1996 elm_photocam_bounce_set(Evas_Object *obj,
1997                         Eina_Bool h_bounce,
1998                         Eina_Bool v_bounce)
1999 {
2000    ELM_PHOTOCAM_CHECK(obj);
2001    ELM_PHOTOCAM_DATA_GET(obj, sd);
2002
2003    sd->s_iface->bounce_allow_set(obj, h_bounce, v_bounce);
2004 }
2005
2006 EAPI void
2007 elm_photocam_bounce_get(const Evas_Object *obj,
2008                         Eina_Bool *h_bounce,
2009                         Eina_Bool *v_bounce)
2010 {
2011    ELM_PHOTOCAM_CHECK(obj);
2012    ELM_PHOTOCAM_DATA_GET(obj, sd);
2013
2014    sd->s_iface->bounce_allow_get(obj, h_bounce, v_bounce);
2015 }
2016
2017 EAPI void
2018 elm_photocam_gesture_enabled_set(Evas_Object *obj,
2019                                  Eina_Bool gesture)
2020 {
2021    ELM_PHOTOCAM_CHECK(obj);
2022    ELM_PHOTOCAM_DATA_GET(obj, sd);
2023
2024    gesture = !!gesture;
2025
2026    if (sd->do_gesture == gesture) return;
2027
2028    sd->do_gesture = gesture;
2029
2030    if (sd->g_layer)
2031      {
2032         evas_object_del(sd->g_layer);
2033         sd->g_layer = NULL;
2034      }
2035
2036    if (!gesture) return;
2037
2038    sd->g_layer = elm_gesture_layer_add(obj);
2039    if (!sd->g_layer) return;
2040
2041    elm_gesture_layer_attach(sd->g_layer, obj);
2042    elm_gesture_layer_cb_set
2043      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START,
2044      _g_layer_zoom_start_cb, sd);
2045    elm_gesture_layer_cb_set
2046      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE,
2047      _g_layer_zoom_move_cb, sd);
2048    elm_gesture_layer_cb_set
2049      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_END,
2050      _g_layer_zoom_end_cb, sd);
2051    elm_gesture_layer_cb_set
2052      (sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_ABORT,
2053      _g_layer_zoom_end_cb, sd);
2054 }
2055
2056 EAPI Eina_Bool
2057 elm_photocam_gesture_enabled_get(const Evas_Object *obj)
2058 {
2059    ELM_PHOTOCAM_CHECK(obj) EINA_FALSE;
2060    ELM_PHOTOCAM_DATA_GET(obj, sd);
2061
2062    return sd->do_gesture;
2063 }