2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2014-10-17 08:56:11 -07:00
|
|
|
#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
|
|
|
|
#define ELM_INTERFACE_ATSPI_WIDGET_ACTION_PROTECTED
|
|
|
|
|
2009-09-11 06:43:02 -07:00
|
|
|
#include <Elementary.h>
|
2013-04-25 22:13:00 -07:00
|
|
|
|
2009-09-11 06:43:02 -07:00
|
|
|
#include "elm_priv.h"
|
2012-07-30 15:36:06 -07:00
|
|
|
#include "elm_widget_photocam.h"
|
2012-11-25 22:32:53 -08:00
|
|
|
#include "elm_interface_scrollable.h"
|
|
|
|
|
2014-06-03 03:35:28 -07:00
|
|
|
#define MY_PAN_CLASS ELM_PHOTOCAM_PAN_CLASS
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
#define MY_PAN_CLASS_NAME "Elm_Photocam_Pan"
|
|
|
|
#define MY_PAN_CLASS_NAME_LEGACY "elm_photocam_pan"
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2014-06-03 03:35:28 -07:00
|
|
|
#define MY_CLASS ELM_PHOTOCAM_CLASS
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
#define MY_CLASS_NAME "Elm_Photocam"
|
|
|
|
#define MY_CLASS_NAME_LEGACY "elm_photocam"
|
2009-09-11 06:43:02 -07:00
|
|
|
|
2011-07-27 13:36:47 -07:00
|
|
|
/*
|
2009-09-25 02:26:04 -07:00
|
|
|
* TODO (maybe - optional future stuff):
|
2011-04-01 04:24:15 -07:00
|
|
|
*
|
2009-09-25 02:26:04 -07:00
|
|
|
* 1. wrap photo in theme edje so u can have styling around photo (like white
|
|
|
|
* photo bordering).
|
|
|
|
* 2. exif handling
|
|
|
|
* 3. rotation flags in exif handling (nasty! should have rot in evas)
|
2009-09-11 06:43:02 -07:00
|
|
|
*/
|
2011-07-27 13:36:47 -07:00
|
|
|
|
2011-04-21 17:42:32 -07:00
|
|
|
static const char SIG_CLICKED[] = "clicked";
|
|
|
|
static const char SIG_PRESS[] = "press";
|
|
|
|
static const char SIG_LONGPRESSED[] = "longpressed";
|
|
|
|
static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
|
|
|
|
static const char SIG_LOAD[] = "load";
|
|
|
|
static const char SIG_LOADED[] = "loaded";
|
|
|
|
static const char SIG_LOAD_DETAIL[] = "load,detail";
|
|
|
|
static const char SIG_LOADED_DETAIL[] = "loaded,detail";
|
|
|
|
static const char SIG_ZOOM_START[] = "zoom,start";
|
|
|
|
static const char SIG_ZOOM_STOP[] = "zoom,stop";
|
|
|
|
static const char SIG_ZOOM_CHANGE[] = "zoom,change";
|
|
|
|
static const char SIG_SCROLL[] = "scroll";
|
|
|
|
static const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
|
|
|
|
static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
|
|
|
|
static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
|
|
|
|
static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
|
2013-08-11 20:14:45 -07:00
|
|
|
static const char SIG_DOWNLOAD_START[] = "download,start";
|
|
|
|
static const char SIG_DOWNLOAD_PROGRESS[] = "download,progress";
|
|
|
|
static const char SIG_DOWNLOAD_DONE[] = "download,done";
|
|
|
|
static const char SIG_DOWNLOAD_ERROR[] = "download,error";
|
2012-07-04 14:43:29 -07:00
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] = {
|
2011-04-21 17:42:32 -07:00
|
|
|
{SIG_CLICKED, ""},
|
|
|
|
{SIG_PRESS, ""},
|
|
|
|
{SIG_LONGPRESSED, ""},
|
|
|
|
{SIG_CLICKED_DOUBLE, ""},
|
|
|
|
{SIG_LOAD, ""},
|
|
|
|
{SIG_LOADED, ""},
|
|
|
|
{SIG_LOAD_DETAIL, ""},
|
|
|
|
{SIG_LOADED_DETAIL, ""},
|
|
|
|
{SIG_ZOOM_START, ""},
|
|
|
|
{SIG_ZOOM_STOP, ""},
|
|
|
|
{SIG_ZOOM_CHANGE, ""},
|
|
|
|
{SIG_SCROLL, ""},
|
|
|
|
{SIG_SCROLL_ANIM_START, ""},
|
|
|
|
{SIG_SCROLL_ANIM_STOP, ""},
|
|
|
|
{SIG_SCROLL_DRAG_START, ""},
|
|
|
|
{SIG_SCROLL_DRAG_STOP, ""},
|
2013-08-11 20:14:45 -07:00
|
|
|
{SIG_DOWNLOAD_START, ""},
|
|
|
|
{SIG_DOWNLOAD_PROGRESS, ""},
|
|
|
|
{SIG_DOWNLOAD_DONE, ""},
|
|
|
|
{SIG_DOWNLOAD_ERROR, ""},
|
2014-01-23 00:24:19 -08:00
|
|
|
{SIG_WIDGET_FOCUSED, ""}, /**< handled by elm_widget */
|
|
|
|
{SIG_WIDGET_UNFOCUSED, ""}, /**< handled by elm_widget */
|
2011-04-21 17:42:32 -07:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2015-05-05 05:16:19 -07:00
|
|
|
static Eina_Error PHOTO_FILE_LOAD_ERROR_GENERIC;
|
|
|
|
static Eina_Error PHOTO_FILE_LOAD_ERROR_DOES_NOT_EXIST;
|
|
|
|
static Eina_Error PHOTO_FILE_LOAD_ERROR_PERMISSION_DENIED;
|
|
|
|
static Eina_Error PHOTO_FILE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
|
|
|
|
static Eina_Error PHOTO_FILE_LOAD_ERROR_CORRUPT_FILE;
|
|
|
|
static Eina_Error PHOTO_FILE_LOAD_ERROR_UNKNOWN_FORMAT;
|
|
|
|
|
2014-04-15 00:07:17 -07:00
|
|
|
static Eina_Bool _key_action_move(Evas_Object *obj, const char *params);
|
|
|
|
static Eina_Bool _key_action_zoom(Evas_Object *obj, const char *params);
|
|
|
|
|
|
|
|
static const Elm_Action key_actions[] = {
|
|
|
|
{"move", _key_action_move},
|
|
|
|
{"zoom", _key_action_zoom},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2013-08-11 20:14:45 -07:00
|
|
|
static inline void
|
2014-03-25 01:49:47 -07:00
|
|
|
_photocam_image_file_set(Evas_Object *obj, Elm_Photocam_Data *sd)
|
2013-08-11 20:14:45 -07:00
|
|
|
{
|
|
|
|
if (sd->f)
|
|
|
|
evas_object_image_mmap_set(obj, sd->f, NULL);
|
|
|
|
else
|
|
|
|
evas_object_image_file_set(obj, sd->file, NULL);
|
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
static void
|
|
|
|
_sizing_eval(Evas_Object *obj)
|
2009-10-13 20:23:03 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
|
2013-10-05 01:15:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_size_hint_max_get
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, &maxw, &maxh);
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
evas_object_size_hint_max_set(obj, maxw, maxh);
|
2009-10-13 20:23:03 -07:00
|
|
|
}
|
|
|
|
|
2009-09-15 03:58:35 -07:00
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_calc_job_cb(void *data)
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = data;
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2012-07-04 14:43:29 -07:00
|
|
|
Evas_Coord minw, minh;
|
|
|
|
|
|
|
|
minw = sd->size.w;
|
|
|
|
minh = sd->size.h;
|
|
|
|
if (sd->resized)
|
|
|
|
{
|
|
|
|
sd->resized = EINA_FALSE;
|
|
|
|
if (sd->mode != ELM_PHOTOCAM_ZOOM_MODE_MANUAL)
|
|
|
|
{
|
|
|
|
double tz = sd->zoom;
|
|
|
|
sd->zoom = 0.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_photocam_zoom_set(obj, tz);
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((minw != sd->minw) || (minh != sd->minh))
|
|
|
|
{
|
|
|
|
sd->minw = minw;
|
|
|
|
sd->minh = minh;
|
|
|
|
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(sd->pan_obj, eo_event_callback_call(ELM_PAN_EVENT_CHANGED, NULL));
|
2012-11-25 22:32:53 -08:00
|
|
|
_sizing_eval(obj);
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
sd->calc_job = NULL;
|
|
|
|
evas_object_smart_changed(sd->pan_obj);
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_pan_evas_object_smart_move(Eo *obj EINA_UNUSED, Elm_Photocam_Pan_Data *psd, Evas_Coord x EINA_UNUSED, Evas_Coord y EINA_UNUSED)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(psd->wsd->calc_job);
|
2012-11-25 22:32:53 -08:00
|
|
|
psd->wsd->calc_job = ecore_job_add(_calc_job_cb, psd->wobj);
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_pan_evas_object_smart_resize(Eo *obj, Elm_Photocam_Pan_Data *psd, Evas_Coord w, Evas_Coord h)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
Evas_Coord ow, oh;
|
|
|
|
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
if ((ow == w) && (oh == h)) return;
|
|
|
|
|
|
|
|
psd->wsd->resized = EINA_TRUE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(psd->wsd->calc_job);
|
2012-11-25 22:32:53 -08:00
|
|
|
psd->wsd->calc_job = ecore_job_add(_calc_job_cb, psd->wobj);
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_image_place(Evas_Object *obj,
|
|
|
|
Evas_Coord px,
|
|
|
|
Evas_Coord py,
|
|
|
|
Evas_Coord ox,
|
|
|
|
Evas_Coord oy,
|
|
|
|
Evas_Coord ow,
|
|
|
|
Evas_Coord oh)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2009-09-24 00:17:52 -07:00
|
|
|
Evas_Coord ax, ay, gw, gh;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
ax = 0;
|
|
|
|
ay = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
gw = sd->size.w;
|
|
|
|
gh = sd->size.h;
|
|
|
|
if (!sd->zoom_g_layer)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
|
|
|
if (ow > gw) ax = (ow - gw) / 2;
|
|
|
|
if (oh > gh) ay = (oh - gh) / 2;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_move(sd->img, ox + 0 - px + ax, oy + 0 - py + ay);
|
|
|
|
evas_object_resize(sd->img, gw, gh);
|
2009-11-17 07:55:59 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->show.show)
|
2009-11-17 07:55:59 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->show.show = EINA_FALSE;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_region_show
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->show.x, sd->show.y, sd->show.w, sd->show.h));
|
2009-11-17 07:55:59 -08:00
|
|
|
}
|
2009-09-24 00:17:52 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_grid_load(Evas_Object *obj,
|
|
|
|
Elm_Phocam_Grid *g)
|
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh, gw, gh, tx, ty;
|
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2013-10-05 01:15:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_geometry_get(sd->pan_obj, &ox, &oy, &ow, &oh);
|
|
|
|
evas_output_viewport_get(evas_object_evas_get(obj), &cvx, &cvy, &cvw, &cvh);
|
|
|
|
|
|
|
|
gw = sd->size.w;
|
|
|
|
gh = sd->size.h;
|
|
|
|
for (y = 0; y < g->gh; y++)
|
|
|
|
{
|
|
|
|
for (x = 0; x < g->gw; x++)
|
|
|
|
{
|
|
|
|
int tn, xx, yy, ww, hh;
|
|
|
|
Eina_Bool visible = EINA_FALSE;
|
|
|
|
|
|
|
|
tn = (y * g->gw) + x;
|
|
|
|
xx = g->grid[tn].out.x;
|
|
|
|
yy = g->grid[tn].out.y;
|
|
|
|
ww = g->grid[tn].out.w;
|
|
|
|
hh = g->grid[tn].out.h;
|
|
|
|
if ((gw != g->w) && (g->w > 0))
|
|
|
|
{
|
|
|
|
tx = xx;
|
|
|
|
xx = (gw * xx) / g->w;
|
|
|
|
ww = ((gw * (tx + ww)) / g->w) - xx;
|
|
|
|
}
|
|
|
|
if ((gh != g->h) && (g->h > 0))
|
|
|
|
{
|
|
|
|
ty = yy;
|
|
|
|
yy = (gh * yy) / g->h;
|
|
|
|
hh = ((gh * (ty + hh)) / g->h) - yy;
|
|
|
|
}
|
|
|
|
if (ELM_RECTS_INTERSECT(xx - sd->pan_x + ox,
|
|
|
|
yy - sd->pan_y + oy,
|
|
|
|
ww, hh, cvx, cvy, cvw, cvh))
|
|
|
|
visible = EINA_TRUE;
|
|
|
|
if ((visible) && (!g->grid[tn].have) && (!g->grid[tn].want))
|
|
|
|
{
|
|
|
|
g->grid[tn].want = 1;
|
|
|
|
evas_object_hide(g->grid[tn].img);
|
|
|
|
evas_object_image_file_set(g->grid[tn].img, NULL, NULL);
|
|
|
|
evas_object_image_load_scale_down_set
|
|
|
|
(g->grid[tn].img, g->zoom);
|
|
|
|
evas_object_image_load_region_set
|
|
|
|
(g->grid[tn].img, g->grid[tn].src.x, g->grid[tn].src.y,
|
|
|
|
g->grid[tn].src.w, g->grid[tn].src.h);
|
2013-08-11 20:14:45 -07:00
|
|
|
_photocam_image_file_set(g->grid[tn].img, sd);
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_image_preload(g->grid[tn].img, 0);
|
|
|
|
sd->preload_num++;
|
|
|
|
if (sd->preload_num == 1)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj,
|
2012-07-04 14:43:29 -07:00
|
|
|
"elm,state,busy,start", "elm");
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_LOAD_DETAIL, NULL));
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((g->grid[tn].want) && (!visible))
|
|
|
|
{
|
|
|
|
sd->preload_num--;
|
|
|
|
if (!sd->preload_num)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj,
|
2012-07-04 14:43:29 -07:00
|
|
|
"elm,state,busy,stop", "elm");
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_LOADED_DETAIL, NULL));
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
g->grid[tn].want = 0;
|
|
|
|
evas_object_hide(g->grid[tn].img);
|
|
|
|
evas_object_image_preload(g->grid[tn].img, 1);
|
|
|
|
evas_object_image_file_set(g->grid[tn].img, NULL, NULL);
|
|
|
|
}
|
|
|
|
else if ((g->grid[tn].have) && (!visible))
|
|
|
|
{
|
|
|
|
g->grid[tn].have = 0;
|
|
|
|
evas_object_hide(g->grid[tn].img);
|
|
|
|
evas_object_image_preload(g->grid[tn].img, 1);
|
|
|
|
evas_object_image_file_set(g->grid[tn].img, NULL, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_grid_place(Evas_Object *obj,
|
|
|
|
Elm_Phocam_Grid *g,
|
|
|
|
Evas_Coord px,
|
|
|
|
Evas_Coord py,
|
|
|
|
Evas_Coord ox,
|
|
|
|
Evas_Coord oy,
|
|
|
|
Evas_Coord ow,
|
|
|
|
Evas_Coord oh)
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
|
|
|
Evas_Coord ax, ay, gw, gh, tx, ty;
|
|
|
|
int x, y;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
ax = 0;
|
|
|
|
ay = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
gw = sd->size.w;
|
|
|
|
gh = sd->size.h;
|
|
|
|
if (!sd->zoom_g_layer)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
|
|
|
if (ow > gw) ax = (ow - gw) / 2;
|
|
|
|
if (oh > gh) ay = (oh - gh) / 2;
|
|
|
|
}
|
2009-09-24 00:17:52 -07:00
|
|
|
for (y = 0; y < g->gh; y++)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2009-09-24 00:17:52 -07:00
|
|
|
for (x = 0; x < g->gw; x++)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
|
|
|
int tn, xx, yy, ww, hh;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
tn = (y * g->gw) + x;
|
|
|
|
xx = g->grid[tn].out.x;
|
|
|
|
yy = g->grid[tn].out.y;
|
|
|
|
ww = g->grid[tn].out.w;
|
|
|
|
hh = g->grid[tn].out.h;
|
2009-09-25 02:26:04 -07:00
|
|
|
if ((gw != g->w) && (g->w > 0))
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
|
|
|
tx = xx;
|
|
|
|
xx = (gw * xx) / g->w;
|
|
|
|
ww = ((gw * (tx + ww)) / g->w) - xx;
|
|
|
|
}
|
2009-09-25 02:26:04 -07:00
|
|
|
if ((gh != g->h) && (g->h > 0))
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
|
|
|
ty = yy;
|
|
|
|
yy = (gh * yy) / g->h;
|
|
|
|
hh = ((gh * (ty + hh)) / g->h) - yy;
|
|
|
|
}
|
|
|
|
evas_object_move(g->grid[tn].img,
|
|
|
|
ox + xx - px + ax,
|
|
|
|
oy + yy - py + ay);
|
2009-09-28 15:18:03 -07:00
|
|
|
evas_object_resize(g->grid[tn].img, ww, hh);
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_pan_evas_object_smart_calculate(Eo *obj, Elm_Photocam_Pan_Data *psd)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
Elm_Phocam_Grid *g;
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
|
2013-10-05 01:15:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(psd->wobj, wd);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
|
|
|
|
_image_place(
|
2012-11-25 22:32:53 -08:00
|
|
|
wd->obj, psd->wsd->pan_x, psd->wsd->pan_y,
|
2012-07-04 14:43:29 -07:00
|
|
|
ox - psd->wsd->g_layer_zoom.imx, oy - psd->wsd->g_layer_zoom.imy, ow,
|
|
|
|
oh);
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(psd->wsd->grids, l, g)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
_grid_load(wd->obj, g);
|
2012-07-04 14:43:29 -07:00
|
|
|
_grid_place(
|
2012-11-25 22:32:53 -08:00
|
|
|
wd->obj, g, psd->wsd->pan_x,
|
2012-07-04 14:43:29 -07:00
|
|
|
psd->wsd->pan_y, ox - psd->wsd->g_layer_zoom.imx,
|
|
|
|
oy - psd->wsd->g_layer_zoom.imy, ow, oh);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_pan_elm_pan_pos_set(Eo *obj, Elm_Photocam_Pan_Data *psd, Evas_Coord x, Evas_Coord y)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
if ((x == psd->wsd->pan_x) && (y == psd->wsd->pan_y)) return;
|
|
|
|
psd->wsd->pan_x = x;
|
|
|
|
psd->wsd->pan_y = y;
|
|
|
|
evas_object_smart_changed(obj);
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_pan_elm_pan_pos_get(Eo *obj EINA_UNUSED, Elm_Photocam_Pan_Data *psd, Evas_Coord *x, Evas_Coord *y)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
if (x) *x = psd->wsd->pan_x;
|
|
|
|
if (y) *y = psd->wsd->pan_y;
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_pan_elm_pan_pos_max_get(Eo *obj, Elm_Photocam_Pan_Data *psd, Evas_Coord *x, Evas_Coord *y)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
Evas_Coord ow, oh;
|
|
|
|
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
ow = psd->wsd->minw - ow;
|
|
|
|
if (ow < 0) ow = 0;
|
|
|
|
oh = psd->wsd->minh - oh;
|
|
|
|
if (oh < 0) oh = 0;
|
|
|
|
if (x) *x = ow;
|
|
|
|
if (y) *y = oh;
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_pan_elm_pan_pos_min_get(Eo *obj EINA_UNUSED, Elm_Photocam_Pan_Data *_pd EINA_UNUSED, Evas_Coord *x, Evas_Coord *y)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
if (x) *x = 0;
|
|
|
|
if (y) *y = 0;
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_pan_elm_pan_content_size_get(Eo *obj EINA_UNUSED, Elm_Photocam_Pan_Data *psd, Evas_Coord *w, Evas_Coord *h)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
if (w) *w = psd->wsd->minw;
|
|
|
|
if (h) *h = psd->wsd->minh;
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_pan_eo_base_destructor(Eo *obj, Elm_Photocam_Pan_Data *psd)
|
2013-04-24 04:41:37 -07:00
|
|
|
{
|
|
|
|
eo_data_unref(psd->wobj, psd->wsd);
|
|
|
|
eo_do_super(obj, MY_PAN_CLASS, eo_destructor());
|
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
static void
|
2014-03-25 01:49:47 -07:00
|
|
|
_elm_photocam_pan_class_constructor(Eo_Class *klass)
|
|
|
|
{
|
|
|
|
evas_smart_legacy_type_register(MY_PAN_CLASS_NAME_LEGACY, klass);
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
#include "elm_photocam_pan.eo.c"
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
static int
|
|
|
|
_nearest_pow2_get(int num)
|
|
|
|
{
|
|
|
|
unsigned int n = num - 1;
|
|
|
|
|
|
|
|
n |= n >> 1;
|
|
|
|
n |= n >> 2;
|
|
|
|
n |= n >> 4;
|
|
|
|
n |= n >> 8;
|
|
|
|
n |= n >> 16;
|
|
|
|
|
|
|
|
return n + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_grid_clear(Evas_Object *obj,
|
|
|
|
Elm_Phocam_Grid *g)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
|
|
|
int x, y;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2013-10-05 01:15:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
if (!g->grid) return;
|
|
|
|
for (y = 0; y < g->gh; y++)
|
2009-09-23 01:19:03 -07:00
|
|
|
{
|
2009-09-24 00:17:52 -07:00
|
|
|
for (x = 0; x < g->gw; x++)
|
2009-09-23 01:19:03 -07:00
|
|
|
{
|
|
|
|
int tn;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
tn = (y * g->gw) + x;
|
|
|
|
evas_object_del(g->grid[tn].img);
|
2009-09-25 02:26:04 -07:00
|
|
|
if (g->grid[tn].want)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->preload_num--;
|
|
|
|
if (!sd->preload_num)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj,
|
2012-07-04 14:43:29 -07:00
|
|
|
"elm,state,busy,stop", "elm");
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_LOAD_DETAIL, NULL));
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
|
|
|
}
|
2009-09-23 01:19:03 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2014-01-21 18:08:47 -08:00
|
|
|
ELM_SAFE_FREE(g->grid, free);
|
2009-09-24 00:17:52 -07:00
|
|
|
g->gw = 0;
|
|
|
|
g->gh = 0;
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_tile_preloaded_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *o EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Photocam_Grid_Item *git = data;
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_PHOTOCAM_DATA_GET(git->obj, sd);
|
2013-10-05 01:15:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(git->obj, wd);
|
2009-09-15 03:58:35 -07:00
|
|
|
|
2009-09-25 02:26:04 -07:00
|
|
|
if (git->want)
|
|
|
|
{
|
|
|
|
git->want = 0;
|
|
|
|
evas_object_show(git->img);
|
|
|
|
git->have = 1;
|
2012-11-25 22:32:53 -08:00
|
|
|
sd->preload_num--;
|
|
|
|
if (!sd->preload_num)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm,state,busy,stop",
|
2012-07-04 14:43:29 -07:00
|
|
|
"elm");
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(wd->obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_LOADED_DETAIL, NULL));
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
|
|
|
}
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
|
|
|
|
2009-10-13 20:23:03 -07:00
|
|
|
static int
|
2012-07-04 14:43:29 -07:00
|
|
|
_grid_zoom_calc(double zoom)
|
2009-10-13 20:23:03 -07:00
|
|
|
{
|
|
|
|
int z = zoom;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2009-10-13 20:23:03 -07:00
|
|
|
if (z < 1) z = 1;
|
2012-07-04 14:43:29 -07:00
|
|
|
return _nearest_pow2_get(z);
|
2009-10-13 20:23:03 -07:00
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
static Elm_Phocam_Grid *
|
|
|
|
_grid_create(Evas_Object *obj)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
|
|
|
int x, y;
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Phocam_Grid *g;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
g = calloc(1, sizeof(Elm_Phocam_Grid));
|
2011-11-29 16:12:10 -08:00
|
|
|
if (!g) return NULL;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
g->zoom = _grid_zoom_calc(sd->zoom);
|
|
|
|
g->tsize = sd->tsize;
|
|
|
|
g->iw = sd->size.imw;
|
|
|
|
g->ih = sd->size.imh;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
g->w = g->iw / g->zoom;
|
|
|
|
g->h = g->ih / g->zoom;
|
2011-11-29 16:12:10 -08:00
|
|
|
if (g->zoom >= 8)
|
|
|
|
{
|
|
|
|
free(g);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2011-11-29 16:12:10 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->do_region)
|
2011-12-14 13:03:55 -08:00
|
|
|
{
|
|
|
|
g->gw = (g->w + g->tsize - 1) / g->tsize;
|
|
|
|
g->gh = (g->h + g->tsize - 1) / g->tsize;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g->gw = 1;
|
|
|
|
g->gh = 1;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
g->grid = calloc(1, sizeof(Elm_Photocam_Grid_Item) * g->gw * g->gh);
|
2009-09-24 00:17:52 -07:00
|
|
|
if (!g->grid)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2009-09-24 00:17:52 -07:00
|
|
|
g->gw = 0;
|
|
|
|
g->gh = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
return g;
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
for (y = 0; y < g->gh; y++)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2009-09-24 00:17:52 -07:00
|
|
|
for (x = 0; x < g->gw; x++)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
int tn;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
tn = (y * g->gw) + x;
|
|
|
|
g->grid[tn].src.x = x * g->tsize;
|
|
|
|
if (x == (g->gw - 1))
|
|
|
|
g->grid[tn].src.w = g->w - ((g->gw - 1) * g->tsize);
|
2009-09-15 03:58:35 -07:00
|
|
|
else
|
2009-09-24 00:17:52 -07:00
|
|
|
g->grid[tn].src.w = g->tsize;
|
|
|
|
g->grid[tn].src.y = y * g->tsize;
|
|
|
|
if (y == (g->gh - 1))
|
|
|
|
g->grid[tn].src.h = g->h - ((g->gh - 1) * g->tsize);
|
2009-09-15 03:58:35 -07:00
|
|
|
else
|
2009-09-24 00:17:52 -07:00
|
|
|
g->grid[tn].src.h = g->tsize;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
g->grid[tn].out.x = g->grid[tn].src.x;
|
|
|
|
g->grid[tn].out.y = g->grid[tn].src.y;
|
|
|
|
g->grid[tn].out.w = g->grid[tn].src.w;
|
|
|
|
g->grid[tn].out.h = g->grid[tn].src.h;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
g->grid[tn].obj = obj;
|
2011-04-01 04:24:15 -07:00
|
|
|
g->grid[tn].img =
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_image_add(evas_object_evas_get(obj));
|
2011-09-29 02:03:16 -07:00
|
|
|
evas_object_image_load_orientation_set(g->grid[tn].img, EINA_TRUE);
|
2015-02-20 05:33:04 -08:00
|
|
|
evas_object_image_orient_set(g->grid[tn].img, sd->orient);
|
2009-10-13 20:23:03 -07:00
|
|
|
evas_object_image_scale_hint_set
|
2012-07-04 14:43:29 -07:00
|
|
|
(g->grid[tn].img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
|
2010-09-27 21:28:14 -07:00
|
|
|
evas_object_pass_events_set(g->grid[tn].img, EINA_TRUE);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
/* XXX: check this */
|
|
|
|
evas_object_smart_member_add(g->grid[tn].img, sd->pan_obj);
|
2009-09-24 00:17:52 -07:00
|
|
|
elm_widget_sub_object_add(obj, g->grid[tn].img);
|
|
|
|
evas_object_image_filled_set(g->grid[tn].img, 1);
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_event_callback_add
|
|
|
|
(g->grid[tn].img, EVAS_CALLBACK_IMAGE_PRELOADED,
|
|
|
|
_tile_preloaded_cb, &(g->grid[tn]));
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
return g;
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_grid_clear_all(Evas_Object *obj)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Phocam_Grid *g;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2009-09-15 03:58:35 -07:00
|
|
|
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(sd->grids, g)
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
_grid_clear(obj, g);
|
2009-09-24 00:17:52 -07:00
|
|
|
free(g);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-22 07:04:09 -07:00
|
|
|
static void
|
|
|
|
_smooth_update(Evas_Object *obj)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Phocam_Grid *g;
|
2009-09-22 07:04:09 -07:00
|
|
|
int x, y;
|
2009-09-24 00:17:52 -07:00
|
|
|
Eina_List *l;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->grids, l, g)
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
|
|
|
for (y = 0; y < g->gh; y++)
|
|
|
|
{
|
|
|
|
for (x = 0; x < g->gw; x++)
|
|
|
|
{
|
|
|
|
int tn;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
tn = (y * g->gw) + x;
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_image_smooth_scale_set
|
|
|
|
(g->grid[tn].img, (!sd->no_smooth));
|
2009-09-24 00:17:52 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_image_smooth_scale_set(sd->img, (!sd->no_smooth));
|
2009-09-24 00:17:52 -07:00
|
|
|
}
|
2009-09-22 07:04:09 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_grid_raise(Elm_Phocam_Grid *g)
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
|
|
|
int x, y;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
for (y = 0; y < g->gh; y++)
|
2009-09-22 07:04:09 -07:00
|
|
|
{
|
2009-09-24 00:17:52 -07:00
|
|
|
for (x = 0; x < g->gw; x++)
|
2009-09-22 07:04:09 -07:00
|
|
|
{
|
|
|
|
int tn;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
tn = (y * g->gw) + x;
|
|
|
|
evas_object_raise(g->grid[tn].img);
|
2009-09-22 07:04:09 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2012-07-04 14:43:29 -07:00
|
|
|
_scroll_timeout_cb(void *data)
|
2009-09-22 07:04:09 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ELM_PHOTOCAM_DATA_GET(data, sd);
|
2009-09-22 07:04:09 -07:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->no_smooth--;
|
|
|
|
if (!sd->no_smooth) _smooth_update(data);
|
|
|
|
|
|
|
|
sd->scr_timer = NULL;
|
|
|
|
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2009-09-22 07:04:09 -07:00
|
|
|
}
|
|
|
|
|
2009-09-24 00:17:52 -07:00
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_main_img_preloaded_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
|
|
|
Evas_Object *o EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
|
|
|
Evas_Object *obj = data;
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Phocam_Grid *g;
|
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(data, sd);
|
2013-10-05 01:15:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(data, wd);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_show(sd->img);
|
|
|
|
sd->main_load_pending = 0;
|
|
|
|
g = _grid_create(obj);
|
2009-09-24 00:17:52 -07:00
|
|
|
if (g)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->grids = eina_list_prepend(sd->grids, g);
|
|
|
|
_grid_load(obj, g);
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2012-11-25 22:32:53 -08:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job_cb, data);
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(data, eo_event_callback_call(ELM_PHOTOCAM_EVENT_LOADED, NULL));
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->preload_num--;
|
|
|
|
if (!sd->preload_num)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm,state,busy,stop", "elm");
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_LOADED_DETAIL, NULL));
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2009-09-15 03:58:35 -07:00
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2012-07-04 14:43:29 -07:00
|
|
|
_zoom_do(Evas_Object *obj,
|
|
|
|
double t)
|
2009-09-15 03:58:35 -07:00
|
|
|
{
|
2014-04-03 08:41:05 -07:00
|
|
|
Evas_Coord xx, yy, ow = 0, oh = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
sd->size.w = (sd->size.ow * (1.0 - t)) + (sd->size.nw * t);
|
|
|
|
sd->size.h = (sd->size.oh * (1.0 - t)) + (sd->size.nh * t);
|
entry: wrong viewport value calculation issue fix
Summary:
Issue: As entire scroller edje co-ordinates was being taken instead of the actual viewport value,
if in scroller edje more parts are added apart from just "elm.swallow.content", then the viewport value
set will be wrong. hence the selection handlers will not hide when they have to hide.
solution: Instead of taking scroller edje's geometry, get the actual viewport values.
To get viewport x,y a new scrollable interface is also added.
signed-off by: Shilpa Singh <shilpa.singh@samsung.com>
@fix
Test Plan: Selection handlers have to hide correctly when the text is scrolled in a scrolled entry, if the scroller edc of entry has more parts added other than elm.swallow.content, then when we scroll the selection handlers are not hidden correctly.
Reviewers: jaehwan, woohyun, seoz, Hermet, raster
CC: govi, rajeshps, thiepha
Differential Revision: https://phab.enlightenment.org/D674
2014-04-20 20:31:49 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_viewport_geometry_get
|
|
|
|
(NULL, NULL, &ow, &oh));
|
2012-07-04 14:43:29 -07:00
|
|
|
xx = (sd->size.spos.x * sd->size.w) - (ow / 2);
|
|
|
|
yy = (sd->size.spos.y * sd->size.h) - (oh / 2);
|
2009-09-24 01:55:12 -07:00
|
|
|
if (xx < 0) xx = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
else if (xx > (sd->size.w - ow))
|
|
|
|
xx = sd->size.w - ow;
|
2009-09-24 01:55:12 -07:00
|
|
|
if (yy < 0) yy = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
else if (yy > (sd->size.h - oh))
|
|
|
|
yy = sd->size.h - oh;
|
2009-11-17 07:55:59 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->show.show = EINA_TRUE;
|
|
|
|
sd->show.x = xx;
|
|
|
|
sd->show.y = yy;
|
|
|
|
sd->show.w = ow;
|
|
|
|
sd->show.h = oh;
|
2009-11-17 07:55:59 -08:00
|
|
|
|
2015-04-21 21:24:19 -07:00
|
|
|
if (sd->orientation_changed)
|
|
|
|
{
|
|
|
|
evas_object_smart_member_del(sd->img);
|
|
|
|
elm_widget_sub_object_del(obj, sd->img);
|
|
|
|
evas_object_smart_member_add(sd->img, sd->pan_obj);
|
|
|
|
elm_widget_sub_object_add(obj, sd->img);
|
|
|
|
}
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2012-11-25 22:32:53 -08:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job_cb, obj);
|
2009-09-24 00:17:52 -07:00
|
|
|
if (t >= 1.0)
|
|
|
|
{
|
|
|
|
Eina_List *l, *l_next;
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Phocam_Grid *g;
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH_SAFE(sd->grids, l, l_next, g)
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
|
|
|
if (g->dead)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->grids = eina_list_remove_list(sd->grids, l);
|
|
|
|
_grid_clear(obj, g);
|
2009-09-24 00:17:52 -07:00
|
|
|
free(g);
|
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
return EINA_FALSE;
|
2009-10-14 07:03:42 -07:00
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
2009-10-14 07:03:42 -07:00
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2012-07-04 14:43:29 -07:00
|
|
|
_zoom_anim_cb(void *data)
|
2009-10-14 07:03:42 -07:00
|
|
|
{
|
|
|
|
double t;
|
2010-06-25 02:58:14 -07:00
|
|
|
Eina_Bool go;
|
2012-07-04 14:43:29 -07:00
|
|
|
Evas_Object *obj = data;
|
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
|
|
|
|
2009-10-14 07:03:42 -07:00
|
|
|
t = ecore_loop_time_get();
|
2012-07-04 14:43:29 -07:00
|
|
|
if (t >= sd->t_end)
|
2009-10-14 07:03:42 -07:00
|
|
|
t = 1.0;
|
2012-07-04 14:43:29 -07:00
|
|
|
else if (sd->t_end > sd->t_start)
|
|
|
|
t = (t - sd->t_start) / (sd->t_end - sd->t_start);
|
2009-10-14 07:03:42 -07:00
|
|
|
else
|
|
|
|
t = 1.0;
|
|
|
|
t = 1.0 - t;
|
|
|
|
t = 1.0 - (t * t);
|
2012-07-04 14:43:29 -07:00
|
|
|
go = _zoom_do(obj, t);
|
2009-10-14 07:03:42 -07:00
|
|
|
if (!go)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->no_smooth--;
|
|
|
|
if (!sd->no_smooth) _smooth_update(data);
|
|
|
|
sd->zoom_animator = NULL;
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(EVAS_ZOOMABLE_INTERFACE_EVENT_ZOOM_STOP, NULL));
|
2009-09-24 00:17:52 -07:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
return go;
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2012-07-04 14:43:29 -07:00
|
|
|
_long_press_cb(void *data)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ELM_PHOTOCAM_DATA_GET(data, sd);
|
|
|
|
|
|
|
|
sd->long_timer = NULL;
|
|
|
|
sd->longpressed = EINA_TRUE;
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(data, eo_event_callback_call
|
|
|
|
(EVAS_CLICKABLE_INTERFACE_EVENT_LONGPRESSED, NULL));
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_mouse_down_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-07-04 14:43:29 -07:00
|
|
|
void *event_info)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(data, sd);
|
|
|
|
|
2009-09-25 02:26:04 -07:00
|
|
|
if (ev->button != 1) return;
|
2012-07-04 14:43:29 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) sd->on_hold = EINA_TRUE;
|
|
|
|
else sd->on_hold = EINA_FALSE;
|
2009-09-25 02:26:04 -07:00
|
|
|
if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(data, eo_event_callback_call
|
|
|
|
(EVAS_CLICKABLE_INTERFACE_EVENT_CLICKED_DOUBLE, NULL));
|
2009-09-25 02:26:04 -07:00
|
|
|
else
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(data, eo_event_callback_call(ELM_PHOTOCAM_EVENT_PRESS, NULL));
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->longpressed = EINA_FALSE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_timer_del(sd->long_timer);
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->long_timer = ecore_timer_add
|
|
|
|
(_elm_config->longpress_timeout, _long_press_cb, data);
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2009-09-25 02:26:04 -07:00
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_mouse_up_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-07-04 14:43:29 -07:00
|
|
|
void *event_info)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_DATA_GET(data, sd);
|
|
|
|
|
2009-09-25 02:26:04 -07:00
|
|
|
if (ev->button != 1) return;
|
2012-07-04 14:43:29 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) sd->on_hold = EINA_TRUE;
|
|
|
|
else sd->on_hold = EINA_FALSE;
|
2013-05-29 05:05:37 -07:00
|
|
|
ELM_SAFE_FREE(sd->long_timer, ecore_timer_del);
|
2012-07-04 14:43:29 -07:00
|
|
|
if (!sd->on_hold)
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(data, eo_event_callback_call
|
|
|
|
(EVAS_CLICKABLE_INTERFACE_EVENT_CLICKED, NULL));
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->on_hold = EINA_FALSE;
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2015-09-15 03:41:51 -07:00
|
|
|
_elm_photocam_elm_widget_on_focus(Eo *obj, Elm_Photocam_Data *_pd EINA_UNUSED, Elm_Object_Item *item EINA_UNUSED)
|
2009-09-11 06:43:02 -07:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EINA_FALSE);
|
2013-06-06 09:13:37 -07:00
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
|
|
|
|
2015-09-15 03:41:51 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, int_ret = elm_obj_widget_on_focus(NULL));
|
2014-03-25 01:49:47 -07:00
|
|
|
if (!int_ret) return EINA_FALSE;
|
2009-09-11 06:43:02 -07:00
|
|
|
|
2010-09-29 05:22:30 -07:00
|
|
|
if (elm_widget_focus_get(obj))
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm,action,focus", "elm");
|
|
|
|
evas_object_focus_set(wd->resize_obj, EINA_TRUE);
|
2010-09-29 05:22:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm,action,unfocus", "elm");
|
|
|
|
evas_object_focus_set(wd->resize_obj, EINA_FALSE);
|
2010-09-29 05:22:30 -07:00
|
|
|
}
|
2009-09-11 06:43:02 -07:00
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
return EINA_TRUE;
|
2009-09-11 06:43:02 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_photocam_elm_widget_theme_apply(Eo *obj, Elm_Photocam_Data *sd EINA_UNUSED)
|
2009-09-11 06:43:02 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
2014-04-03 08:41:05 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, int_ret = elm_obj_widget_theme_apply());
|
2014-03-25 01:49:47 -07:00
|
|
|
if (!int_ret) return EINA_FALSE;
|
2009-09-11 06:43:02 -07:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
_sizing_eval(obj);
|
2009-09-11 06:43:02 -07:00
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
return EINA_TRUE;
|
2009-09-11 06:43:02 -07:00
|
|
|
}
|
|
|
|
|
2010-11-23 12:20:41 -08:00
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_scroll_animate_start_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
2010-11-23 12:20:41 -08:00
|
|
|
{
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(EVAS_SCROLLABLE_INTERFACE_EVENT_SCROLL_ANIM_START, NULL));
|
2010-11-23 12:20:41 -08:00
|
|
|
}
|
|
|
|
|
2009-09-11 06:43:02 -07:00
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_scroll_animate_stop_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
2009-09-11 06:43:02 -07:00
|
|
|
{
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(EVAS_SCROLLABLE_INTERFACE_EVENT_SCROLL_ANIM_STOP, NULL));
|
2009-09-11 06:43:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_scroll_drag_start_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
2009-09-11 06:43:02 -07:00
|
|
|
{
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(EVAS_SCROLLABLE_INTERFACE_EVENT_SCROLL_DRAG_START, NULL));
|
2009-09-11 06:43:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_scroll_drag_stop_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
2009-09-11 06:43:02 -07:00
|
|
|
{
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(EVAS_SCROLLABLE_INTERFACE_EVENT_SCROLL_DRAG_STOP, NULL));
|
2009-09-11 06:43:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-04 14:43:29 -07:00
|
|
|
_scroll_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
2009-09-11 06:43:02 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2009-09-11 06:43:02 -07:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (!sd->scr_timer)
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->no_smooth++;
|
|
|
|
if (sd->no_smooth == 1) _smooth_update(obj);
|
2009-09-24 00:17:52 -07:00
|
|
|
}
|
2009-09-11 06:43:02 -07:00
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_timer_del(sd->scr_timer);
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->scr_timer = ecore_timer_add(0.5, _scroll_timeout_cb, obj);
|
2009-10-14 01:41:36 -07:00
|
|
|
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(EVAS_SCROLLABLE_INTERFACE_EVENT_SCROLL, NULL));
|
2009-10-14 01:41:36 -07:00
|
|
|
}
|
|
|
|
|
2014-04-15 00:07:17 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_key_action_move(Evas_Object *obj, const char *params)
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
2014-04-15 00:07:17 -07:00
|
|
|
const char *dir = params;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2011-01-04 02:09:48 -08:00
|
|
|
Evas_Coord x = 0;
|
|
|
|
Evas_Coord y = 0;
|
|
|
|
Evas_Coord v_h = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
Evas_Coord step_x = 0;
|
|
|
|
Evas_Coord step_y = 0;
|
2011-01-04 02:09:48 -08:00
|
|
|
Evas_Coord page_x = 0;
|
|
|
|
Evas_Coord page_y = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj,
|
2014-03-17 04:44:40 -07:00
|
|
|
elm_interface_scrollable_content_pos_get(&x, &y),
|
|
|
|
elm_interface_scrollable_step_size_get(&step_x, &step_y),
|
|
|
|
elm_interface_scrollable_page_size_get(&page_x, &page_y),
|
entry: wrong viewport value calculation issue fix
Summary:
Issue: As entire scroller edje co-ordinates was being taken instead of the actual viewport value,
if in scroller edje more parts are added apart from just "elm.swallow.content", then the viewport value
set will be wrong. hence the selection handlers will not hide when they have to hide.
solution: Instead of taking scroller edje's geometry, get the actual viewport values.
To get viewport x,y a new scrollable interface is also added.
signed-off by: Shilpa Singh <shilpa.singh@samsung.com>
@fix
Test Plan: Selection handlers have to hide correctly when the text is scrolled in a scrolled entry, if the scroller edc of entry has more parts added other than elm.swallow.content, then when we scroll the selection handlers are not hidden correctly.
Reviewers: jaehwan, woohyun, seoz, Hermet, raster
CC: govi, rajeshps, thiepha
Differential Revision: https://phab.enlightenment.org/D674
2014-04-20 20:31:49 -07:00
|
|
|
elm_interface_scrollable_content_viewport_geometry_get
|
|
|
|
(NULL, NULL, NULL, &v_h));
|
2011-01-04 02:09:48 -08:00
|
|
|
|
2014-04-15 00:07:17 -07:00
|
|
|
if (!strcmp(dir, "left"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
x -= step_x;
|
|
|
|
}
|
2014-04-15 00:07:17 -07:00
|
|
|
else if (!strcmp(dir, "right"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
x += step_x;
|
|
|
|
}
|
2014-04-15 00:07:17 -07:00
|
|
|
else if (!strcmp(dir, "up"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
y -= step_y;
|
|
|
|
}
|
2014-04-15 00:07:17 -07:00
|
|
|
else if (!strcmp(dir, "down"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
y += step_y;
|
|
|
|
}
|
2014-04-15 00:07:17 -07:00
|
|
|
else if (!strcmp(dir, "prior"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
if (page_y < 0)
|
2011-04-01 04:24:15 -07:00
|
|
|
y -= -(page_y * v_h) / 100;
|
2011-01-04 02:09:48 -08:00
|
|
|
else
|
2011-04-01 04:24:15 -07:00
|
|
|
y -= page_y;
|
2011-01-04 02:09:48 -08:00
|
|
|
}
|
2014-04-15 00:07:17 -07:00
|
|
|
else if (!strcmp(dir, "next"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
if (page_y < 0)
|
2011-04-01 04:24:15 -07:00
|
|
|
y += -(page_y * v_h) / 100;
|
2011-01-04 02:09:48 -08:00
|
|
|
else
|
2011-04-01 04:24:15 -07:00
|
|
|
y += page_y;
|
2011-01-04 02:09:48 -08:00
|
|
|
}
|
2014-04-15 00:07:17 -07:00
|
|
|
else return EINA_FALSE;
|
|
|
|
|
|
|
|
eo_do(obj, elm_interface_scrollable_content_pos_set(x, y, EINA_TRUE));
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_key_action_zoom(Evas_Object *obj, const char *params)
|
|
|
|
{
|
|
|
|
const char *dir = params;
|
|
|
|
double zoom;
|
|
|
|
|
|
|
|
if (!strcmp(dir, "in"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
zoom = elm_photocam_zoom_get(obj);
|
|
|
|
zoom -= 0.5;
|
|
|
|
elm_photocam_zoom_mode_set(obj, ELM_PHOTOCAM_ZOOM_MODE_MANUAL);
|
|
|
|
elm_photocam_zoom_set(obj, zoom);
|
2011-04-01 04:24:15 -07:00
|
|
|
}
|
2014-04-15 00:07:17 -07:00
|
|
|
else if (!strcmp(dir, "out"))
|
2011-01-04 02:09:48 -08:00
|
|
|
{
|
|
|
|
zoom = elm_photocam_zoom_get(obj);
|
|
|
|
zoom += 0.5;
|
|
|
|
elm_photocam_zoom_mode_set(obj, ELM_PHOTOCAM_ZOOM_MODE_MANUAL);
|
|
|
|
elm_photocam_zoom_set(obj, zoom);
|
|
|
|
}
|
2014-03-25 01:49:47 -07:00
|
|
|
else return EINA_FALSE;
|
2011-01-04 02:09:48 -08:00
|
|
|
|
2014-04-15 00:07:17 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_photocam_elm_widget_event(Eo *obj, Elm_Photocam_Data *_pd EINA_UNUSED, Evas_Object *src, Evas_Callback_Type type, void *event_info)
|
|
|
|
{
|
|
|
|
(void) src;
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
|
|
|
|
|
|
|
if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
|
2011-01-04 02:09:48 -08:00
|
|
|
|
2014-04-15 00:07:17 -07:00
|
|
|
if (!_elm_config_key_binding_call(obj, ev, key_actions))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2014-03-25 01:49:47 -07:00
|
|
|
return EINA_TRUE;
|
2011-01-04 02:09:48 -08:00
|
|
|
}
|
|
|
|
|
2012-02-24 09:58:29 -08:00
|
|
|
Eina_Bool
|
2012-07-04 14:43:29 -07:00
|
|
|
_bounce_eval(void *data)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = data;
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2012-02-24 09:58:29 -08:00
|
|
|
double t, tt;
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((sd->g_layer_zoom.imx == sd->g_layer_zoom.bounce.x_end) &&
|
|
|
|
(sd->g_layer_zoom.imy == sd->g_layer_zoom.bounce.y_end))
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.imx = 0;
|
|
|
|
sd->g_layer_zoom.imy = 0;
|
|
|
|
sd->zoom_g_layer = EINA_FALSE;
|
|
|
|
sd->g_layer_zoom.bounce.animator = NULL;
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_freeze_set(EINA_FALSE));
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2012-02-24 09:58:29 -08:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
t = ecore_loop_time_get();
|
2012-07-04 14:43:29 -07:00
|
|
|
tt = (t - sd->g_layer_zoom.bounce.t_start) /
|
|
|
|
(sd->g_layer_zoom.bounce.t_end -
|
|
|
|
sd->g_layer_zoom.bounce.t_start);
|
2012-02-24 09:58:29 -08:00
|
|
|
tt = 1.0 - tt;
|
|
|
|
tt = 1.0 - (tt * tt);
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (t > sd->g_layer_zoom.bounce.t_end)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.imx = 0;
|
|
|
|
sd->g_layer_zoom.imy = 0;
|
|
|
|
sd->zoom_g_layer = EINA_FALSE;
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_freeze_set(EINA_FALSE));
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
_zoom_do(obj, 1.0);
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.bounce.animator = NULL;
|
2012-02-24 09:58:29 -08:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->g_layer_zoom.imx != sd->g_layer_zoom.bounce.x_end)
|
|
|
|
sd->g_layer_zoom.imx =
|
|
|
|
sd->g_layer_zoom.bounce.x_start * (1.0 - tt) +
|
|
|
|
sd->g_layer_zoom.bounce.x_end * tt;
|
|
|
|
|
|
|
|
if (sd->g_layer_zoom.imy != sd->g_layer_zoom.bounce.y_end)
|
|
|
|
sd->g_layer_zoom.imy =
|
|
|
|
sd->g_layer_zoom.bounce.y_start * (1.0 - tt) +
|
|
|
|
sd->g_layer_zoom.bounce.y_end * tt;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
_zoom_do(obj, 1.0 - (1.0 - tt));
|
2012-02-24 09:58:29 -08:00
|
|
|
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_g_layer_zoom_do(Evas_Object *obj,
|
2012-07-04 14:43:29 -07:00
|
|
|
Evas_Coord px,
|
|
|
|
Evas_Coord py,
|
|
|
|
Elm_Gesture_Zoom_Info *g_layer)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
|
|
|
int regx, regy, regw, regh, ix, iy, iw, ih;
|
2014-04-03 08:41:05 -07:00
|
|
|
Evas_Coord rx, ry, rw = 0, rh = 0;
|
2012-02-24 09:58:29 -08:00
|
|
|
int xx, yy;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->mode = ELM_PHOTOCAM_ZOOM_MODE_MANUAL;
|
|
|
|
sd->zoom = sd->g_layer_start / g_layer->zoom;
|
|
|
|
sd->size.ow = sd->size.w;
|
|
|
|
sd->size.oh = sd->size.h;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_pos_get(&rx, &ry));
|
entry: wrong viewport value calculation issue fix
Summary:
Issue: As entire scroller edje co-ordinates was being taken instead of the actual viewport value,
if in scroller edje more parts are added apart from just "elm.swallow.content", then the viewport value
set will be wrong. hence the selection handlers will not hide when they have to hide.
solution: Instead of taking scroller edje's geometry, get the actual viewport values.
To get viewport x,y a new scrollable interface is also added.
signed-off by: Shilpa Singh <shilpa.singh@samsung.com>
@fix
Test Plan: Selection handlers have to hide correctly when the text is scrolled in a scrolled entry, if the scroller edc of entry has more parts added other than elm.swallow.content, then when we scroll the selection handlers are not hidden correctly.
Reviewers: jaehwan, woohyun, seoz, Hermet, raster
CC: govi, rajeshps, thiepha
Differential Revision: https://phab.enlightenment.org/D674
2014-04-20 20:31:49 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_viewport_geometry_get
|
|
|
|
(NULL, NULL, &rw, &rh));
|
2012-02-24 09:58:29 -08:00
|
|
|
if ((rw <= 0) || (rh <= 0)) return;
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.nw = (double)sd->size.imw / sd->zoom;
|
|
|
|
sd->size.nh = (double)sd->size.imh / sd->zoom;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
elm_photocam_image_region_get(obj, ®x, ®y, ®w, ®h);
|
|
|
|
evas_object_geometry_get(sd->img, &ix, &iy, &iw, &ih);
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->pvx = g_layer->x;
|
|
|
|
sd->pvy = g_layer->y;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
xx = (px / sd->zoom) - sd->pvx;
|
|
|
|
yy = (py / sd->zoom) - sd->pvy;
|
|
|
|
sd->g_layer_zoom.imx = 0;
|
|
|
|
sd->g_layer_zoom.imy = 0;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((xx < 0) || (rw > sd->size.nw))
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.imx = xx;
|
2012-02-24 09:58:29 -08:00
|
|
|
xx = 0;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
else if ((xx + rw) > sd->size.nw)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.imx = xx + rw - sd->size.nw;
|
|
|
|
xx = sd->size.nw - rw;
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((yy < 0) || (rh > sd->size.nh))
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.imy = yy;
|
2012-02-24 09:58:29 -08:00
|
|
|
yy = 0;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
else if ((yy + rh) > sd->size.nh)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.imy = yy + rh - sd->size.nh;
|
|
|
|
yy = sd->size.nh - rh;
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.spos.x = (double)(xx + (rw / 2)) / (double)(sd->size.nw);
|
|
|
|
sd->size.spos.y = (double)(yy + (rh / 2)) / (double)(sd->size.nh);
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
_zoom_do(obj, 1.0);
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Event_Flags
|
2012-07-04 14:43:29 -07:00
|
|
|
_g_layer_zoom_start_cb(void *data,
|
|
|
|
void *event_info)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = data;
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Gesture_Zoom_Info *p = event_info;
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2012-02-24 09:58:29 -08:00
|
|
|
double marginx = 0, marginy = 0;
|
2014-04-03 08:41:05 -07:00
|
|
|
Evas_Coord rw = 0, rh = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
int x, y, w, h;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2013-05-29 05:05:37 -07:00
|
|
|
ELM_SAFE_FREE(sd->g_layer_zoom.bounce.animator, ecore_animator_del);
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom_g_layer = EINA_TRUE;
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_freeze_set(EINA_TRUE));
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_photocam_image_region_get(obj, &x, &y, &w, &h);
|
entry: wrong viewport value calculation issue fix
Summary:
Issue: As entire scroller edje co-ordinates was being taken instead of the actual viewport value,
if in scroller edje more parts are added apart from just "elm.swallow.content", then the viewport value
set will be wrong. hence the selection handlers will not hide when they have to hide.
solution: Instead of taking scroller edje's geometry, get the actual viewport values.
To get viewport x,y a new scrollable interface is also added.
signed-off by: Shilpa Singh <shilpa.singh@samsung.com>
@fix
Test Plan: Selection handlers have to hide correctly when the text is scrolled in a scrolled entry, if the scroller edc of entry has more parts added other than elm.swallow.content, then when we scroll the selection handlers are not hidden correctly.
Reviewers: jaehwan, woohyun, seoz, Hermet, raster
CC: govi, rajeshps, thiepha
Differential Revision: https://phab.enlightenment.org/D674
2014-04-20 20:31:49 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_viewport_geometry_get
|
|
|
|
(NULL, NULL, &rw, &rh));
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (rw > sd->size.nw)
|
|
|
|
marginx = (rw - sd->size.nw) / 2;
|
|
|
|
if (rh > sd->size.nh)
|
|
|
|
marginy = (rh - sd->size.nh) / 2;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_start = sd->zoom;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom_point_x = x + ((p->x - marginx) * sd->zoom) +
|
|
|
|
sd->g_layer_zoom.imx;
|
|
|
|
sd->zoom_point_y = y + ((p->y - marginy) * sd->zoom) +
|
|
|
|
sd->g_layer_zoom.imy;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Event_Flags
|
2012-07-04 14:43:29 -07:00
|
|
|
_g_layer_zoom_move_cb(void *data,
|
|
|
|
void *event_info)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
Elm_Photocam_Data *sd = eo_data_scope_get(data, MY_CLASS);
|
2012-07-04 14:43:29 -07:00
|
|
|
Elm_Gesture_Zoom_Info *p = event_info;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
_g_layer_zoom_do(data, sd->zoom_point_x, sd->zoom_point_y, p);
|
2012-02-24 09:58:29 -08:00
|
|
|
|
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Evas_Event_Flags
|
2012-07-04 14:43:29 -07:00
|
|
|
_g_layer_zoom_end_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *event_info EINA_UNUSED)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = data;
|
|
|
|
ELM_PHOTOCAM_DATA_GET(obj, sd);
|
2012-02-24 09:58:29 -08:00
|
|
|
Evas_Coord rw, rh;
|
|
|
|
|
entry: wrong viewport value calculation issue fix
Summary:
Issue: As entire scroller edje co-ordinates was being taken instead of the actual viewport value,
if in scroller edje more parts are added apart from just "elm.swallow.content", then the viewport value
set will be wrong. hence the selection handlers will not hide when they have to hide.
solution: Instead of taking scroller edje's geometry, get the actual viewport values.
To get viewport x,y a new scrollable interface is also added.
signed-off by: Shilpa Singh <shilpa.singh@samsung.com>
@fix
Test Plan: Selection handlers have to hide correctly when the text is scrolled in a scrolled entry, if the scroller edc of entry has more parts added other than elm.swallow.content, then when we scroll the selection handlers are not hidden correctly.
Reviewers: jaehwan, woohyun, seoz, Hermet, raster
CC: govi, rajeshps, thiepha
Differential Revision: https://phab.enlightenment.org/D674
2014-04-20 20:31:49 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_viewport_geometry_get
|
|
|
|
(NULL, NULL, &rw, &rh));
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_start = 1.0;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->g_layer_zoom.imx || sd->g_layer_zoom.imy)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
|
|
|
double t;
|
|
|
|
|
|
|
|
t = ecore_loop_time_get();
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.bounce.x_start = sd->g_layer_zoom.imx;
|
|
|
|
sd->g_layer_zoom.bounce.y_start = sd->g_layer_zoom.imy;
|
|
|
|
sd->g_layer_zoom.bounce.x_end = 0;
|
|
|
|
sd->g_layer_zoom.bounce.y_end = 0;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (rw > sd->size.nw &&
|
|
|
|
rh > sd->size.nh)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
|
|
|
Evas_Coord pw, ph;
|
|
|
|
double z;
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((sd->size.imw < rw) && (sd->size.imh < rh))
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom = 1;
|
|
|
|
sd->size.nw = sd->size.imw;
|
|
|
|
sd->size.nh = sd->size.imh;
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ph = (sd->size.imh * rw) / sd->size.imw;
|
2012-02-24 09:58:29 -08:00
|
|
|
if (ph > rh)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
pw = (sd->size.imw * rh) / sd->size.imh;
|
2012-02-24 09:58:29 -08:00
|
|
|
ph = rh;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pw = rw;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->size.imw > sd->size.imh)
|
|
|
|
z = (double)sd->size.imw / pw;
|
2012-02-24 09:58:29 -08:00
|
|
|
else
|
2012-07-04 14:43:29 -07:00
|
|
|
z = (double)sd->size.imh / ph;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom = z;
|
|
|
|
sd->size.nw = pw;
|
|
|
|
sd->size.nh = ph;
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.bounce.x_end = (sd->size.nw - rw) / 2;
|
|
|
|
sd->g_layer_zoom.bounce.y_end = (sd->size.nh - rh) / 2;
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int xx, yy;
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
xx = (sd->zoom_point_x / sd->zoom) - sd->pvx;
|
|
|
|
yy = (sd->zoom_point_y / sd->zoom) - sd->pvy;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
|
|
|
if (xx < 0) xx = 0;
|
|
|
|
if (yy < 0) yy = 0;
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (rw > sd->size.nw)
|
|
|
|
sd->g_layer_zoom.bounce.x_end = (sd->size.nw - rw) / 2;
|
|
|
|
if ((xx + rw) > sd->size.nw)
|
|
|
|
xx = sd->size.nw - rw;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (rh > sd->size.nh)
|
|
|
|
sd->g_layer_zoom.bounce.y_end = (sd->size.nh - rh) / 2;
|
|
|
|
if ((yy + rh) > sd->size.nh)
|
|
|
|
yy = sd->size.nh - rh;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.spos.x = (double)(xx + (rw / 2)) / (double)(sd->size.nw);
|
|
|
|
sd->size.spos.y = (double)(yy + (rh / 2)) / (double)(sd->size.nh);
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.bounce.t_start = t;
|
|
|
|
sd->g_layer_zoom.bounce.t_end = t +
|
|
|
|
_elm_config->page_scroll_friction;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->g_layer_zoom.bounce.animator =
|
2013-04-24 04:41:37 -07:00
|
|
|
ecore_animator_add(_bounce_eval, obj);
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_freeze_set(EINA_FALSE));
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom_g_layer = EINA_FALSE;
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
return EVAS_EVENT_FLAG_NONE;
|
|
|
|
}
|
|
|
|
|
2015-02-20 05:33:04 -08:00
|
|
|
static void
|
|
|
|
_orient_do(Evas_Object *obj, Elm_Photocam_Data *sd)
|
|
|
|
{
|
|
|
|
evas_object_smart_member_del(sd->img);
|
|
|
|
elm_widget_sub_object_del(obj, sd->img);
|
|
|
|
evas_object_smart_member_add(sd->img, sd->pan_obj);
|
|
|
|
elm_widget_sub_object_add(obj, sd->img);
|
|
|
|
ecore_job_del(sd->calc_job);
|
|
|
|
sd->calc_job = ecore_job_add(_calc_job_cb, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_image_orient_set(Eo *obj, Elm_Photocam_Data *sd, Evas_Image_Orient orient)
|
|
|
|
{
|
|
|
|
int iw, ih;
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Phocam_Grid *g, *g_orient = NULL;
|
|
|
|
|
2015-04-28 02:38:50 -07:00
|
|
|
if (sd->orient == orient) return;
|
|
|
|
|
2015-04-21 21:24:19 -07:00
|
|
|
sd->orientation_changed = EINA_TRUE;
|
2015-02-20 05:33:04 -08:00
|
|
|
sd->orient = orient;
|
|
|
|
g = _grid_create(obj);
|
|
|
|
if (g)
|
|
|
|
{
|
|
|
|
if (eina_list_count(sd->grids) > 1)
|
|
|
|
{
|
|
|
|
g_orient = eina_list_last(sd->grids)->data;
|
|
|
|
sd->grids = eina_list_remove(sd->grids, g_orient);
|
|
|
|
_grid_clear(obj, g_orient);
|
|
|
|
free(g_orient);
|
|
|
|
EINA_LIST_FOREACH(sd->grids, l, g_orient)
|
|
|
|
{
|
|
|
|
g_orient->dead = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sd->grids = eina_list_prepend(sd->grids, g);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
EINA_LIST_FREE(sd->grids, g)
|
|
|
|
{
|
|
|
|
_grid_clear(obj, g);
|
|
|
|
free(g);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
evas_object_image_orient_set(sd->img, orient);
|
|
|
|
evas_object_image_size_get(sd->img, &iw, &ih);
|
|
|
|
sd->size.imw = iw;
|
|
|
|
sd->size.imh = ih;
|
|
|
|
sd->size.w = iw / sd->zoom;
|
|
|
|
sd->size.h = ih / sd->zoom;
|
|
|
|
_orient_do(obj, sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Evas_Image_Orient
|
|
|
|
_elm_photocam_image_orient_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd)
|
|
|
|
{
|
|
|
|
return sd->orient;
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_evas_object_smart_add(Eo *obj, Elm_Photocam_Data *priv)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
2012-07-17 09:38:07 -07:00
|
|
|
Eina_Bool bounce = _elm_config->thumbscroll_bounce_enable;
|
2014-03-25 01:49:47 -07:00
|
|
|
Elm_Photocam_Pan_Data *pan_data;
|
2013-02-16 05:39:59 -08:00
|
|
|
Evas_Object *edje;
|
2013-09-24 21:33:39 -07:00
|
|
|
Evas_Coord minw, minh;
|
2012-07-17 09:38:07 -07:00
|
|
|
|
2013-09-24 21:33:39 -07:00
|
|
|
elm_widget_sub_object_parent_add(obj);
|
2013-08-26 22:19:19 -07:00
|
|
|
|
2013-02-16 05:39:59 -08:00
|
|
|
edje = edje_object_add(evas_object_evas_get(obj));
|
2013-10-16 08:54:54 -07:00
|
|
|
elm_widget_resize_object_set(obj, edje, EINA_TRUE);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_add());
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
elm_widget_theme_object_set
|
2013-02-16 05:39:59 -08:00
|
|
|
(obj, edje, "photocam", "base", elm_widget_style_get(obj));
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
priv->hit_rect = evas_object_rectangle_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_smart_member_add(priv->hit_rect, obj);
|
|
|
|
elm_widget_sub_object_add(obj, priv->hit_rect);
|
|
|
|
|
2012-07-17 09:38:07 -07:00
|
|
|
/* common scroller hit rectangle setup */
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_color_set(priv->hit_rect, 0, 0, 0, 0);
|
|
|
|
evas_object_show(priv->hit_rect);
|
|
|
|
evas_object_repeat_events_set(priv->hit_rect, EINA_TRUE);
|
|
|
|
|
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
2012-07-17 09:38:07 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_objects_set(edje, priv->hit_rect));
|
2012-07-17 09:38:07 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj,
|
2014-03-17 04:44:40 -07:00
|
|
|
elm_interface_scrollable_animate_start_cb_set(_scroll_animate_start_cb),
|
|
|
|
elm_interface_scrollable_animate_stop_cb_set(_scroll_animate_stop_cb),
|
|
|
|
elm_interface_scrollable_drag_start_cb_set(_scroll_drag_start_cb),
|
|
|
|
elm_interface_scrollable_drag_stop_cb_set(_scroll_drag_stop_cb),
|
|
|
|
elm_interface_scrollable_scroll_cb_set(_scroll_cb));
|
2012-07-17 09:38:07 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_bounce_allow_set(bounce, bounce));
|
2012-07-17 09:38:07 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
priv->pan_obj = eo_add(MY_PAN_CLASS, evas_object_evas_get(obj));
|
2013-04-24 04:41:37 -07:00
|
|
|
pan_data = eo_data_scope_get(priv->pan_obj, MY_PAN_CLASS);
|
|
|
|
eo_data_ref(obj, NULL);
|
2012-11-25 22:32:53 -08:00
|
|
|
pan_data->wobj = obj;
|
2012-07-17 09:38:07 -07:00
|
|
|
pan_data->wsd = priv;
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_extern_pan_set(priv->pan_obj));
|
2012-07-17 09:38:07 -07:00
|
|
|
|
|
|
|
priv->g_layer_start = 1.0;
|
|
|
|
priv->zoom = 1;
|
|
|
|
priv->mode = ELM_PHOTOCAM_ZOOM_MODE_MANUAL;
|
|
|
|
priv->tsize = 512;
|
|
|
|
|
|
|
|
priv->img = evas_object_image_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_image_load_orientation_set(priv->img, EINA_TRUE);
|
|
|
|
evas_object_image_scale_hint_set(priv->img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(priv->img, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, obj);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(priv->img, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, obj);
|
|
|
|
evas_object_image_scale_hint_set(priv->img, EVAS_IMAGE_SCALE_HINT_STATIC);
|
|
|
|
|
|
|
|
/* XXX: mmm... */
|
|
|
|
evas_object_smart_member_add(priv->img, priv->pan_obj);
|
|
|
|
|
|
|
|
elm_widget_sub_object_add(obj, priv->img);
|
|
|
|
evas_object_image_filled_set(priv->img, EINA_TRUE);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(priv->img, EVAS_CALLBACK_IMAGE_PRELOADED, _main_img_preloaded_cb, obj);
|
|
|
|
|
2013-02-16 05:39:59 -08:00
|
|
|
edje_object_size_min_calc(edje, &minw, &minh);
|
2012-07-17 09:38:07 -07:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
|
|
|
|
_sizing_eval(obj);
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_evas_object_smart_del(Eo *obj, Elm_Photocam_Data *sd)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
Elm_Phocam_Grid *g;
|
|
|
|
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(sd->grids, g)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
2014-01-21 18:08:47 -08:00
|
|
|
free(g->grid);
|
2012-07-04 14:43:29 -07:00
|
|
|
free(g);
|
|
|
|
}
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(sd->pan_obj, evas_object_del);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2013-08-11 20:14:45 -07:00
|
|
|
if (sd->f) eina_file_close(sd->f);
|
|
|
|
free(sd->remote_data);
|
2014-01-21 06:23:37 -08:00
|
|
|
if (sd->remote) _elm_url_cancel(sd->remote);
|
2014-01-21 06:16:41 -08:00
|
|
|
eina_stringshare_del(sd->file);
|
|
|
|
ecore_job_del(sd->calc_job);
|
|
|
|
ecore_timer_del(sd->scr_timer);
|
|
|
|
ecore_timer_del(sd->long_timer);
|
|
|
|
ecore_animator_del(sd->zoom_animator);
|
|
|
|
ecore_animator_del(sd->g_layer_zoom.bounce.animator);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
|
2012-07-04 14:43:29 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_evas_object_smart_move(Eo *obj, Elm_Photocam_Data *sd, Evas_Coord x, Evas_Coord y)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_move(x, y));
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_move(sd->hit_rect, x, y);
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_evas_object_smart_resize(Eo *obj, Elm_Photocam_Data *sd, Evas_Coord w, Evas_Coord h)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_resize(w, h));
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_resize(sd->hit_rect, w, h);
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
2014-06-03 03:35:28 -07:00
|
|
|
_elm_photocam_evas_object_smart_member_add(Eo *obj, Elm_Photocam_Data *sd, Evas_Object *member)
|
2012-07-04 14:43:29 -07:00
|
|
|
{
|
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_member_add(member));
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
if (sd->hit_rect)
|
|
|
|
evas_object_raise(sd->hit_rect);
|
|
|
|
}
|
|
|
|
|
2009-09-11 06:43:02 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_photocam_add(Evas_Object *parent)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = eo_add(MY_CLASS, parent);
|
|
|
|
return obj;
|
|
|
|
}
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2015-05-19 05:34:07 -07:00
|
|
|
EOLIAN static Eo *
|
2014-03-25 01:49:47 -07:00
|
|
|
_elm_photocam_eo_base_constructor(Eo *obj, Elm_Photocam_Data *_pd EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2015-05-19 05:34:07 -07:00
|
|
|
obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj,
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_obj_type_set(MY_CLASS_NAME_LEGACY),
|
2014-06-10 19:07:15 -07:00
|
|
|
evas_obj_smart_callbacks_descriptions_set(_smart_callbacks),
|
|
|
|
elm_interface_atspi_accessible_role_set(ELM_ATSPI_ROLE_IMAGE));
|
2015-05-19 05:34:07 -07:00
|
|
|
|
|
|
|
return obj;
|
2009-09-11 06:43:02 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
2014-03-25 01:49:47 -07:00
|
|
|
_internal_file_set(Eo *obj, Elm_Photocam_Data *sd, const char *file, Eina_File *f, Evas_Load_Error *ret)
|
2009-09-11 06:43:02 -07:00
|
|
|
{
|
2013-10-05 01:15:09 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
|
2013-08-11 20:14:45 -07:00
|
|
|
Evas_Load_Error err;
|
2009-09-11 06:43:02 -07:00
|
|
|
int w, h;
|
2012-07-04 14:43:29 -07:00
|
|
|
double tz;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2015-01-13 06:25:10 -08:00
|
|
|
// It is actually to late, we have lost the reference to the previous
|
|
|
|
// file descriptor already, so we can't know if the file changed. To
|
|
|
|
// be safe we do for now just force a full reload on file_set and hope
|
|
|
|
// on evas to catch it, if there is no change.
|
|
|
|
eina_stringshare_replace(&sd->file, file);
|
2013-08-11 20:14:45 -07:00
|
|
|
sd->f = eina_file_dup(f);
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
evas_object_image_smooth_scale_set(sd->img, (sd->no_smooth == 0));
|
|
|
|
evas_object_image_file_set(sd->img, NULL, NULL);
|
|
|
|
evas_object_image_load_scale_down_set(sd->img, 0);
|
2013-08-11 20:14:45 -07:00
|
|
|
_photocam_image_file_set(sd->img, sd);
|
2012-12-27 19:54:24 -08:00
|
|
|
err = evas_object_image_load_error_get(sd->img);
|
|
|
|
if (err != EVAS_LOAD_ERROR_NONE)
|
|
|
|
{
|
2013-08-11 20:14:45 -07:00
|
|
|
ERR("Things are going bad for '%s' (%p) : %i", file, sd->img, err);
|
2012-12-27 19:59:36 -08:00
|
|
|
if (ret) *ret = err;
|
2012-12-27 19:54:24 -08:00
|
|
|
return;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_image_size_get(sd->img, &w, &h);
|
|
|
|
|
|
|
|
sd->do_region = evas_object_image_region_support_get(sd->img);
|
|
|
|
sd->size.imw = w;
|
|
|
|
sd->size.imh = h;
|
|
|
|
sd->size.w = sd->size.imw / sd->zoom;
|
|
|
|
sd->size.h = sd->size.imh / sd->zoom;
|
|
|
|
evas_object_image_file_set(sd->img, NULL, NULL);
|
2013-08-11 20:14:45 -07:00
|
|
|
_photocam_image_file_set(sd->img, sd);
|
2012-12-27 19:54:24 -08:00
|
|
|
err = evas_object_image_load_error_get(sd->img);
|
|
|
|
if (err != EVAS_LOAD_ERROR_NONE)
|
|
|
|
{
|
|
|
|
ERR("Things are going bad for '%s' (%p)", file, sd->img);
|
2012-12-27 19:59:36 -08:00
|
|
|
if (ret) *ret = err;
|
2012-12-27 19:54:24 -08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
evas_object_image_preload(sd->img, 0);
|
|
|
|
sd->main_load_pending = EINA_TRUE;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job_cb, obj);
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_PHOTOCAM_EVENT_LOAD, NULL));
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->preload_num++;
|
|
|
|
if (sd->preload_num == 1)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
edje_object_signal_emit
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm,state,busy,start", "elm");
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_PHOTOCAM_EVENT_LOAD_DETAIL, NULL));
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
tz = sd->zoom;
|
|
|
|
sd->zoom = 0.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_photocam_zoom_set(obj, tz);
|
2015-02-20 05:33:04 -08:00
|
|
|
sd->orient = EVAS_IMAGE_ORIENT_NONE;
|
2015-04-21 21:24:19 -07:00
|
|
|
sd->orientation_changed = EINA_FALSE;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = evas_object_image_load_error_get(sd->img);
|
2009-09-11 06:43:02 -07:00
|
|
|
}
|
2009-09-22 07:04:09 -07:00
|
|
|
|
2013-08-11 20:14:45 -07:00
|
|
|
static void
|
|
|
|
_elm_photocam_download_done(void *data, Elm_Url *url EINA_UNUSED, Eina_Binbuf *download)
|
|
|
|
{
|
|
|
|
Eo *obj = data;
|
2014-03-25 01:49:47 -07:00
|
|
|
Elm_Photocam_Data *sd = eo_data_scope_get(obj, MY_CLASS);
|
2013-08-11 20:14:45 -07:00
|
|
|
Eina_File *f;
|
|
|
|
size_t length;
|
|
|
|
Evas_Load_Error ret = EVAS_LOAD_ERROR_NONE;
|
|
|
|
|
2014-01-21 18:08:47 -08:00
|
|
|
free(sd->remote_data);
|
2013-08-11 20:14:45 -07:00
|
|
|
length = eina_binbuf_length_get(download);
|
|
|
|
sd->remote_data = eina_binbuf_string_steal(download);
|
2014-01-21 06:23:37 -08:00
|
|
|
f = eina_file_virtualize(_elm_url_get(url),
|
2013-08-11 20:14:45 -07:00
|
|
|
sd->remote_data, length,
|
|
|
|
EINA_FALSE);
|
2014-01-21 06:23:37 -08:00
|
|
|
_internal_file_set(obj, sd, _elm_url_get(url), f, &ret);
|
2013-08-11 20:14:45 -07:00
|
|
|
eina_file_close(f);
|
|
|
|
|
|
|
|
if (ret != EVAS_LOAD_ERROR_NONE)
|
|
|
|
{
|
|
|
|
Elm_Photocam_Error err = { 0, EINA_TRUE };
|
|
|
|
|
|
|
|
free(sd->remote_data);
|
|
|
|
sd->remote_data = NULL;
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_DOWNLOAD_ERROR, &err));
|
2013-08-11 20:14:45 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_DOWNLOAD_DONE, NULL));
|
2013-08-11 20:14:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
sd->remote = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_photocam_download_cancel(void *data, Elm_Url *url EINA_UNUSED, int error)
|
|
|
|
{
|
|
|
|
Eo *obj = data;
|
2014-03-25 01:49:47 -07:00
|
|
|
Elm_Photocam_Data *sd = eo_data_scope_get(obj, MY_CLASS);
|
2013-08-11 20:14:45 -07:00
|
|
|
Elm_Photocam_Error err = { error, EINA_FALSE };
|
|
|
|
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(ELM_PHOTOCAM_EVENT_DOWNLOAD_ERROR, &err));
|
2013-08-11 20:14:45 -07:00
|
|
|
|
|
|
|
sd->remote = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_photocam_download_progress(void *data, Elm_Url *url EINA_UNUSED, double now, double total)
|
|
|
|
{
|
|
|
|
Eo *obj = data;
|
|
|
|
Elm_Photocam_Progress progress;
|
|
|
|
|
|
|
|
progress.now = now;
|
|
|
|
progress.total = total;
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_DOWNLOAD_PROGRESS, &progress));
|
2013-08-11 20:14:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char *remote_uri[] = {
|
|
|
|
"http://", "https://", "ftp://"
|
|
|
|
};
|
|
|
|
|
2015-05-05 05:16:19 -07:00
|
|
|
static Evas_Load_Error
|
|
|
|
_elm_photocam_file_set_internal(Eo *obj, Elm_Photocam_Data *sd, const char *file)
|
2013-08-11 20:14:45 -07:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
Evas_Load_Error ret = EVAS_LOAD_ERROR_NONE;
|
2013-08-11 20:14:45 -07:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
_grid_clear_all(obj);
|
|
|
|
ELM_SAFE_FREE(sd->g_layer_zoom.bounce.animator, ecore_animator_del);
|
|
|
|
if (sd->zoom_animator)
|
|
|
|
{
|
|
|
|
sd->no_smooth--;
|
|
|
|
if (sd->no_smooth == 0) _smooth_update(obj);
|
|
|
|
ecore_animator_del(sd->zoom_animator);
|
|
|
|
sd->zoom_animator = NULL;
|
|
|
|
}
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-08-11 20:14:45 -07:00
|
|
|
evas_object_hide(sd->img);
|
|
|
|
if (sd->f) eina_file_close(sd->f);
|
|
|
|
sd->f = NULL;
|
|
|
|
|
|
|
|
free(sd->remote_data);
|
2014-01-21 06:23:37 -08:00
|
|
|
if (sd->remote) _elm_url_cancel(sd->remote);
|
2013-08-11 20:14:45 -07:00
|
|
|
sd->remote = NULL;
|
2014-08-07 07:35:52 -07:00
|
|
|
sd->preload_num = 0;
|
2013-08-11 20:14:45 -07:00
|
|
|
|
|
|
|
for (i = 0; i < sizeof (remote_uri) / sizeof (remote_uri[0]); ++i)
|
2014-01-26 09:07:44 -08:00
|
|
|
if (!strncmp(remote_uri[i], file, strlen(remote_uri[i])))
|
2013-08-11 20:14:45 -07:00
|
|
|
{
|
|
|
|
// Found a remote target !
|
2014-01-21 06:23:37 -08:00
|
|
|
sd->remote = _elm_url_download(file,
|
2013-08-11 20:14:45 -07:00
|
|
|
_elm_photocam_download_done,
|
|
|
|
_elm_photocam_download_cancel,
|
|
|
|
_elm_photocam_download_progress,
|
|
|
|
obj);
|
|
|
|
if (sd->remote)
|
|
|
|
{
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call
|
|
|
|
(ELM_PHOTOCAM_EVENT_DOWNLOAD_START, NULL));
|
2014-03-25 01:49:47 -07:00
|
|
|
return ret;
|
2013-08-11 20:14:45 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
_internal_file_set(obj, sd, file, NULL, &ret);
|
2013-08-11 20:14:45 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
return ret;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2015-05-05 05:16:19 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_photocam_efl_file_file_set(Eo *obj, Elm_Photocam_Data *sd, const char *file, const char *key EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2015-05-05 05:16:19 -07:00
|
|
|
Evas_Load_Error ret = _elm_photocam_file_set_internal(obj, sd, file);
|
|
|
|
|
|
|
|
if (ret == EVAS_LOAD_ERROR_NONE) return EINA_TRUE;
|
|
|
|
|
|
|
|
eina_error_set(
|
|
|
|
ret == EVAS_LOAD_ERROR_DOES_NOT_EXIST ? PHOTO_FILE_LOAD_ERROR_DOES_NOT_EXIST :
|
|
|
|
ret == EVAS_LOAD_ERROR_PERMISSION_DENIED ? PHOTO_FILE_LOAD_ERROR_PERMISSION_DENIED :
|
|
|
|
ret == EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED ? PHOTO_FILE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED :
|
|
|
|
ret == EVAS_LOAD_ERROR_CORRUPT_FILE ? PHOTO_FILE_LOAD_ERROR_CORRUPT_FILE :
|
|
|
|
ret == EVAS_LOAD_ERROR_UNKNOWN_FORMAT ? PHOTO_FILE_LOAD_ERROR_UNKNOWN_FORMAT :
|
|
|
|
PHOTO_FILE_LOAD_ERROR_GENERIC
|
|
|
|
);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Evas_Load_Error
|
|
|
|
elm_photocam_file_set(Elm_Photocam *obj, const char *file)
|
|
|
|
{
|
|
|
|
Eina_Bool ret;
|
2015-12-16 23:09:30 -08:00
|
|
|
|
|
|
|
ELM_PHOTOCAM_CHECK(obj) EVAS_LOAD_ERROR_NONE;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(file, EVAS_LOAD_ERROR_NONE);
|
2015-05-05 05:16:19 -07:00
|
|
|
if (eo_do_ret(obj, ret, efl_file_set(file, NULL))) return EVAS_LOAD_ERROR_NONE;
|
|
|
|
|
|
|
|
Eina_Error err = eina_error_get();
|
|
|
|
return err == PHOTO_FILE_LOAD_ERROR_DOES_NOT_EXIST ?
|
|
|
|
EVAS_LOAD_ERROR_DOES_NOT_EXIST :
|
|
|
|
err == PHOTO_FILE_LOAD_ERROR_PERMISSION_DENIED ?
|
|
|
|
EVAS_LOAD_ERROR_PERMISSION_DENIED :
|
|
|
|
err == PHOTO_FILE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED ?
|
|
|
|
EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED :
|
|
|
|
err == PHOTO_FILE_LOAD_ERROR_CORRUPT_FILE ?
|
|
|
|
EVAS_LOAD_ERROR_CORRUPT_FILE :
|
|
|
|
err == PHOTO_FILE_LOAD_ERROR_UNKNOWN_FORMAT ?
|
|
|
|
EVAS_LOAD_ERROR_UNKNOWN_FORMAT :
|
|
|
|
EVAS_LOAD_ERROR_GENERIC;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_efl_file_file_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd, const char **file, const char **key)
|
|
|
|
{
|
|
|
|
if (file) *file = sd->file;
|
|
|
|
if (key) *key = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char*
|
|
|
|
elm_photocam_file_get(const Elm_Photocam *obj)
|
|
|
|
{
|
|
|
|
const char *ret = NULL;
|
|
|
|
eo_do(obj, efl_file_get(&ret, NULL));
|
|
|
|
return ret;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_zoom_set(Eo *obj, Elm_Photocam_Data *sd, double zoom)
|
2009-09-22 07:04:09 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
double z;
|
2009-09-24 00:17:52 -07:00
|
|
|
Eina_List *l;
|
2012-07-04 14:43:29 -07:00
|
|
|
Ecore_Animator *an;
|
|
|
|
Elm_Phocam_Grid *g, *g_zoom = NULL;
|
2009-09-24 00:17:52 -07:00
|
|
|
Evas_Coord pw, ph, rx, ry, rw, rh;
|
2009-09-25 02:26:04 -07:00
|
|
|
int zoom_changed = 0, started = 0;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2009-10-13 20:23:03 -07:00
|
|
|
if (zoom <= (1.0 / 256.0)) zoom = (1.0 / 256.0);
|
2012-07-04 14:43:29 -07:00
|
|
|
if (zoom == sd->zoom) return;
|
|
|
|
|
|
|
|
sd->zoom = zoom;
|
|
|
|
sd->size.ow = sd->size.w;
|
|
|
|
sd->size.oh = sd->size.h;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_pos_get(&rx, &ry));
|
entry: wrong viewport value calculation issue fix
Summary:
Issue: As entire scroller edje co-ordinates was being taken instead of the actual viewport value,
if in scroller edje more parts are added apart from just "elm.swallow.content", then the viewport value
set will be wrong. hence the selection handlers will not hide when they have to hide.
solution: Instead of taking scroller edje's geometry, get the actual viewport values.
To get viewport x,y a new scrollable interface is also added.
signed-off by: Shilpa Singh <shilpa.singh@samsung.com>
@fix
Test Plan: Selection handlers have to hide correctly when the text is scrolled in a scrolled entry, if the scroller edc of entry has more parts added other than elm.swallow.content, then when we scroll the selection handlers are not hidden correctly.
Reviewers: jaehwan, woohyun, seoz, Hermet, raster
CC: govi, rajeshps, thiepha
Differential Revision: https://phab.enlightenment.org/D674
2014-04-20 20:31:49 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_viewport_geometry_get
|
|
|
|
(NULL, NULL, &rw, &rh));
|
2009-09-28 15:18:03 -07:00
|
|
|
if ((rw <= 0) || (rh <= 0)) return;
|
2009-09-28 15:05:37 -07:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_MANUAL)
|
2009-09-24 01:55:12 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.nw = (double)sd->size.imw / sd->zoom;
|
|
|
|
sd->size.nh = (double)sd->size.imh / sd->zoom;
|
2009-09-24 01:55:12 -07:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT)
|
2009-09-24 01:55:12 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((sd->size.imw < 1) || (sd->size.imh < 1))
|
2009-09-24 01:55:12 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.nw = 0;
|
|
|
|
sd->size.nh = 0;
|
2009-09-24 01:55:12 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ph = (sd->size.imh * rw) / sd->size.imw;
|
2009-09-25 02:26:04 -07:00
|
|
|
if (ph > rh)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
pw = (sd->size.imw * rh) / sd->size.imh;
|
2009-09-25 02:26:04 -07:00
|
|
|
ph = rh;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pw = rw;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->size.imw > sd->size.imh)
|
|
|
|
z = (double)sd->size.imw / pw;
|
2011-12-19 02:00:25 -08:00
|
|
|
else
|
2012-07-04 14:43:29 -07:00
|
|
|
z = (double)sd->size.imh / ph;
|
|
|
|
if (z != sd->zoom)
|
2011-12-14 13:03:55 -08:00
|
|
|
zoom_changed = 1;
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom = z;
|
|
|
|
sd->size.nw = pw;
|
|
|
|
sd->size.nh = ph;
|
2009-09-24 01:55:12 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FILL)
|
2009-09-24 01:55:12 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((sd->size.imw < 1) || (sd->size.imh < 1))
|
2009-09-24 01:55:12 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.nw = 0;
|
|
|
|
sd->size.nw = 0;
|
2009-09-24 01:55:12 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ph = (sd->size.imh * rw) / sd->size.imw;
|
2009-09-25 02:26:04 -07:00
|
|
|
if (ph < rh)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
pw = (sd->size.imw * rh) / sd->size.imh;
|
2009-09-25 02:26:04 -07:00
|
|
|
ph = rh;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pw = rw;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->size.imw > sd->size.imh)
|
|
|
|
z = (double)sd->size.imw / pw;
|
2011-12-19 02:00:25 -08:00
|
|
|
else
|
2012-07-04 14:43:29 -07:00
|
|
|
z = (double)sd->size.imh / ph;
|
|
|
|
if (z != sd->zoom)
|
2011-12-14 13:03:55 -08:00
|
|
|
zoom_changed = 1;
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom = z;
|
|
|
|
sd->size.nw = pw;
|
|
|
|
sd->size.nh = ph;
|
2009-09-24 01:55:12 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
else if (sd->mode == ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT_IN)
|
2011-12-06 07:11:59 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((sd->size.imw < 1) || (sd->size.imh < 1))
|
2011-12-06 07:11:59 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.nw = 0;
|
|
|
|
sd->size.nh = 0;
|
2011-12-06 07:11:59 -08:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
else if ((sd->size.imw < rw) && (sd->size.imh < rh))
|
2011-12-06 07:11:59 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if (1 != sd->zoom) zoom_changed = 1;
|
|
|
|
sd->zoom = 1;
|
|
|
|
sd->size.nw = sd->size.imw;
|
|
|
|
sd->size.nh = sd->size.imh;
|
2011-12-06 07:11:59 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ph = (sd->size.imh * rw) / sd->size.imw;
|
2011-12-06 07:11:59 -08:00
|
|
|
if (ph > rh)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
pw = (sd->size.imw * rh) / sd->size.imh;
|
2011-12-06 07:11:59 -08:00
|
|
|
ph = rh;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
pw = rw;
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->size.imw > sd->size.imh)
|
|
|
|
z = (double)sd->size.imw / pw;
|
2011-12-19 02:00:25 -08:00
|
|
|
else
|
2012-07-04 14:43:29 -07:00
|
|
|
z = (double)sd->size.imh / ph;
|
|
|
|
if (z != sd->zoom)
|
2011-12-14 13:03:55 -08:00
|
|
|
zoom_changed = 1;
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom = z;
|
|
|
|
sd->size.nw = pw;
|
|
|
|
sd->size.nh = ph;
|
2011-12-06 07:11:59 -08:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
if (sd->main_load_pending)
|
2009-09-24 01:55:12 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.w = sd->size.nw;
|
|
|
|
sd->size.h = sd->size.nh;
|
|
|
|
|
2009-09-24 01:55:12 -07:00
|
|
|
goto done;
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->grids, l, g)
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if (g->zoom == _grid_zoom_calc(sd->zoom))
|
2009-09-24 00:17:52 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->grids = eina_list_remove(sd->grids, g);
|
|
|
|
sd->grids = eina_list_prepend(sd->grids, g);
|
2009-10-13 20:23:03 -07:00
|
|
|
_grid_raise(g);
|
|
|
|
goto done;
|
2009-09-24 00:17:52 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
g = _grid_create(obj);
|
2009-09-24 00:17:52 -07:00
|
|
|
if (g)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if (eina_list_count(sd->grids) > 1)
|
2009-10-13 20:23:03 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
g_zoom = eina_list_last(sd->grids)->data;
|
|
|
|
sd->grids = eina_list_remove(sd->grids, g_zoom);
|
|
|
|
_grid_clear(obj, g_zoom);
|
2009-10-13 20:23:03 -07:00
|
|
|
free(g_zoom);
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->grids, l, g_zoom)
|
2009-10-13 20:23:03 -07:00
|
|
|
{
|
|
|
|
g_zoom->dead = 1;
|
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->grids = eina_list_prepend(sd->grids, g);
|
2009-09-24 00:17:52 -07:00
|
|
|
}
|
2009-10-13 20:23:03 -07:00
|
|
|
else
|
|
|
|
{
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(sd->grids, g)
|
2009-10-13 20:23:03 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
_grid_clear(obj, g);
|
2009-10-13 20:23:03 -07:00
|
|
|
free(g);
|
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
done:
|
|
|
|
sd->t_start = ecore_loop_time_get();
|
|
|
|
sd->t_end = sd->t_start + _elm_config->zoom_friction;
|
|
|
|
if ((sd->size.w > 0) && (sd->size.h > 0))
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.spos.x = (double)(rx + (rw / 2)) / (double)sd->size.w;
|
|
|
|
sd->size.spos.y = (double)(ry + (rh / 2)) / (double)sd->size.h;
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->size.spos.x = 0.5;
|
|
|
|
sd->size.spos.y = 0.5;
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
if (rw > sd->size.w) sd->size.spos.x = 0.5;
|
|
|
|
if (rh > sd->size.h) sd->size.spos.y = 0.5;
|
|
|
|
if (sd->size.spos.x > 1.0) sd->size.spos.x = 1.0;
|
|
|
|
if (sd->size.spos.y > 1.0) sd->size.spos.y = 1.0;
|
|
|
|
|
|
|
|
if (sd->paused)
|
2009-10-14 07:03:42 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
_zoom_do(obj, 1.0);
|
2009-10-14 07:03:42 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if (!sd->zoom_animator)
|
2009-10-14 07:03:42 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->zoom_animator = ecore_animator_add(_zoom_anim_cb, obj);
|
|
|
|
sd->no_smooth++;
|
|
|
|
if (sd->no_smooth == 1) _smooth_update(obj);
|
2009-10-14 07:03:42 -07:00
|
|
|
started = 1;
|
|
|
|
}
|
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
an = sd->zoom_animator;
|
2009-10-14 07:03:42 -07:00
|
|
|
if (an)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if (!_zoom_anim_cb(obj))
|
2009-10-14 07:03:42 -07:00
|
|
|
{
|
|
|
|
ecore_animator_del(an);
|
|
|
|
an = NULL;
|
|
|
|
}
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2012-11-25 22:32:53 -08:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job_cb, obj);
|
2012-07-04 14:43:29 -07:00
|
|
|
if (!sd->paused)
|
2009-10-14 07:03:42 -07:00
|
|
|
{
|
|
|
|
if (started)
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(EVAS_ZOOMABLE_INTERFACE_EVENT_ZOOM_START, NULL));
|
2009-10-14 07:03:42 -07:00
|
|
|
if (!an)
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(EVAS_ZOOMABLE_INTERFACE_EVENT_ZOOM_STOP, NULL));
|
2009-10-14 07:03:42 -07:00
|
|
|
}
|
2009-09-25 02:26:04 -07:00
|
|
|
if (zoom_changed)
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(EVAS_ZOOMABLE_INTERFACE_EVENT_ZOOM_CHANGE, NULL));
|
2009-09-22 07:04:09 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static double
|
|
|
|
_elm_photocam_zoom_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd)
|
2009-09-22 07:04:09 -07:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
return sd->zoom;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_zoom_mode_set(Eo *obj, Elm_Photocam_Data *sd, Elm_Photocam_Zoom_Mode mode)
|
2009-09-22 07:04:09 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
double tz;
|
|
|
|
if (sd->mode == mode) return;
|
|
|
|
sd->mode = mode;
|
|
|
|
|
|
|
|
tz = sd->zoom;
|
|
|
|
sd->zoom = 0.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_photocam_zoom_set(obj, tz);
|
2009-09-22 07:04:09 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static Elm_Photocam_Zoom_Mode
|
|
|
|
_elm_photocam_zoom_mode_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd)
|
2009-09-22 07:04:09 -07:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
return sd->mode;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_image_size_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd, int *w, int *h)
|
2009-09-24 06:57:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
if (w) *w = sd->size.imw;
|
|
|
|
if (h) *h = sd->size.imh;
|
2009-09-24 06:57:04 -07:00
|
|
|
}
|
2009-09-25 02:26:04 -07:00
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_image_region_get(Eo *obj, Elm_Photocam_Data *sd, int *x, int *y, int *w, int *h)
|
2009-10-14 01:41:36 -07:00
|
|
|
{
|
|
|
|
Evas_Coord sx, sy, sw, sh;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do((Eo *)obj, elm_interface_scrollable_content_pos_get(&sx, &sy));
|
entry: wrong viewport value calculation issue fix
Summary:
Issue: As entire scroller edje co-ordinates was being taken instead of the actual viewport value,
if in scroller edje more parts are added apart from just "elm.swallow.content", then the viewport value
set will be wrong. hence the selection handlers will not hide when they have to hide.
solution: Instead of taking scroller edje's geometry, get the actual viewport values.
To get viewport x,y a new scrollable interface is also added.
signed-off by: Shilpa Singh <shilpa.singh@samsung.com>
@fix
Test Plan: Selection handlers have to hide correctly when the text is scrolled in a scrolled entry, if the scroller edc of entry has more parts added other than elm.swallow.content, then when we scroll the selection handlers are not hidden correctly.
Reviewers: jaehwan, woohyun, seoz, Hermet, raster
CC: govi, rajeshps, thiepha
Differential Revision: https://phab.enlightenment.org/D674
2014-04-20 20:31:49 -07:00
|
|
|
eo_do((Eo *)obj, elm_interface_scrollable_content_viewport_geometry_get
|
|
|
|
(NULL, NULL, &sw, &sh));
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->size.w > 0)
|
2009-10-14 01:41:36 -07:00
|
|
|
{
|
|
|
|
if (x)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
*x = (sd->size.imw * sx) / sd->size.w;
|
|
|
|
if (*x > sd->size.imw) *x = sd->size.imw;
|
2009-10-14 01:41:36 -07:00
|
|
|
}
|
|
|
|
if (w)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
*w = (sd->size.imw * sw) / sd->size.w;
|
|
|
|
if (*w > sd->size.imw) *w = sd->size.imw;
|
|
|
|
else if (*w < 0)
|
|
|
|
*w = 0;
|
2009-10-14 01:41:36 -07:00
|
|
|
}
|
|
|
|
}
|
2009-11-13 14:22:05 -08:00
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:24:15 -07:00
|
|
|
if (x) *x = 0;
|
|
|
|
if (w) *w = 0;
|
2009-11-13 14:22:05 -08:00
|
|
|
}
|
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->size.h > 0)
|
2009-10-14 01:41:36 -07:00
|
|
|
{
|
|
|
|
if (y)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
*y = (sd->size.imh * sy) / sd->size.h;
|
|
|
|
if (*y > sd->size.imh) *y = sd->size.imh;
|
2009-10-14 01:41:36 -07:00
|
|
|
}
|
|
|
|
if (h)
|
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
*h = (sd->size.imh * sh) / sd->size.h;
|
|
|
|
if (*h > sd->size.imh) *h = sd->size.imh;
|
|
|
|
else if (*h < 0)
|
|
|
|
*h = 0;
|
2009-10-14 01:41:36 -07:00
|
|
|
}
|
|
|
|
}
|
2009-11-13 14:22:05 -08:00
|
|
|
else
|
|
|
|
{
|
2011-04-01 04:24:15 -07:00
|
|
|
if (y) *y = 0;
|
|
|
|
if (h) *h = 0;
|
2009-11-13 14:22:05 -08:00
|
|
|
}
|
2009-10-14 01:41:36 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_image_region_show(Eo *obj, Elm_Photocam_Data *sd, int x, int y, int w, int h)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
|
|
|
int rx, ry, rw, rh;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
if ((sd->size.imw < 1) || (sd->size.imh < 1)) return;
|
|
|
|
rx = (x * sd->size.w) / sd->size.imw;
|
|
|
|
ry = (y * sd->size.h) / sd->size.imh;
|
|
|
|
rw = (w * sd->size.w) / sd->size.imw;
|
|
|
|
rh = (h * sd->size.h) / sd->size.imh;
|
2009-09-25 02:26:04 -07:00
|
|
|
if (rw < 1) rw = 1;
|
|
|
|
if (rh < 1) rh = 1;
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((rx + rw) > sd->size.w) rx = sd->size.w - rw;
|
|
|
|
if ((ry + rh) > sd->size.h) ry = sd->size.h - rh;
|
|
|
|
if (sd->g_layer_zoom.bounce.animator)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ecore_animator_del(sd->g_layer_zoom.bounce.animator);
|
|
|
|
sd->g_layer_zoom.bounce.animator = NULL;
|
|
|
|
_zoom_do(obj, 1.0);
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->zoom_animator)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->no_smooth--;
|
|
|
|
ecore_animator_del(sd->zoom_animator);
|
|
|
|
sd->zoom_animator = NULL;
|
|
|
|
_zoom_do(obj, 1.0);
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(EVAS_ZOOMABLE_INTERFACE_EVENT_ZOOM_STOP, NULL));
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_region_show(rx, ry, rw, rh));
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-04 14:43:29 -07:00
|
|
|
elm_photocam_image_region_bring_in(Evas_Object *obj,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int w,
|
2014-01-06 06:30:02 -08:00
|
|
|
int h EINA_UNUSED)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_PHOTOCAM_CHECK(obj);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_region_bring_in(x, y, w, h));
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_elm_interface_scrollable_region_bring_in(Eo *obj, Elm_Photocam_Data *sd, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2009-09-25 02:26:04 -07:00
|
|
|
int rx, ry, rw, rh;
|
2012-07-04 14:43:29 -07:00
|
|
|
|
|
|
|
if ((sd->size.imw < 1) || (sd->size.imh < 1)) return;
|
|
|
|
rx = (x * sd->size.w) / sd->size.imw;
|
|
|
|
ry = (y * sd->size.h) / sd->size.imh;
|
|
|
|
rw = (w * sd->size.w) / sd->size.imw;
|
|
|
|
rh = (h * sd->size.h) / sd->size.imh;
|
2009-09-25 02:26:04 -07:00
|
|
|
if (rw < 1) rw = 1;
|
|
|
|
if (rh < 1) rh = 1;
|
2012-07-04 14:43:29 -07:00
|
|
|
if ((rx + rw) > sd->size.w) rx = sd->size.w - rw;
|
|
|
|
if ((ry + rh) > sd->size.h) ry = sd->size.h - rh;
|
|
|
|
if (sd->g_layer_zoom.bounce.animator)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ecore_animator_del(sd->g_layer_zoom.bounce.animator);
|
|
|
|
sd->g_layer_zoom.bounce.animator = NULL;
|
|
|
|
_zoom_do(obj, 1.0);
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->zoom_animator)
|
2009-09-25 02:26:04 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
sd->no_smooth--;
|
|
|
|
if (!sd->no_smooth) _smooth_update(obj);
|
|
|
|
ecore_animator_del(sd->zoom_animator);
|
|
|
|
sd->zoom_animator = NULL;
|
|
|
|
_zoom_do(obj, 1.0);
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(EVAS_ZOOMABLE_INTERFACE_EVENT_ZOOM_STOP, NULL));
|
2011-04-01 04:24:15 -07:00
|
|
|
}
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_interface_scrollable_region_bring_in(rx, ry, rw, rh));
|
2009-09-25 02:26:04 -07:00
|
|
|
}
|
2009-10-14 07:03:42 -07:00
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_paused_set(Eo *obj, Elm_Photocam_Data *sd, Eina_Bool paused)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
paused = !!paused;
|
|
|
|
|
|
|
|
if (sd->paused == paused) return;
|
|
|
|
sd->paused = paused;
|
|
|
|
if (!sd->paused) return;
|
|
|
|
|
|
|
|
if (sd->g_layer_zoom.bounce.animator)
|
2009-10-14 07:03:42 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ecore_animator_del(sd->g_layer_zoom.bounce.animator);
|
|
|
|
sd->g_layer_zoom.bounce.animator = NULL;
|
|
|
|
_zoom_do(obj, 1.0);
|
|
|
|
}
|
|
|
|
if (sd->zoom_animator)
|
|
|
|
{
|
|
|
|
ecore_animator_del(sd->zoom_animator);
|
|
|
|
sd->zoom_animator = NULL;
|
|
|
|
_zoom_do(obj, 1.0);
|
2015-05-07 05:44:02 -07:00
|
|
|
eo_do(obj, eo_event_callback_call(EVAS_ZOOMABLE_INTERFACE_EVENT_ZOOM_STOP, NULL));
|
2009-10-14 07:03:42 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_photocam_paused_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd)
|
2009-10-14 07:03:42 -07:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
return sd->paused;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static Evas_Object*
|
|
|
|
_elm_photocam_internal_image_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
return sd->img;
|
2010-01-19 00:24:07 -08:00
|
|
|
}
|
2010-11-04 05:19:00 -07:00
|
|
|
|
|
|
|
EAPI void
|
2012-07-04 14:43:29 -07:00
|
|
|
elm_photocam_bounce_set(Evas_Object *obj,
|
|
|
|
Eina_Bool h_bounce,
|
|
|
|
Eina_Bool v_bounce)
|
2010-11-04 05:19:00 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ELM_PHOTOCAM_CHECK(obj);
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_bounce_allow_set(h_bounce, v_bounce));
|
2010-11-04 05:19:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-04 14:43:29 -07:00
|
|
|
elm_photocam_bounce_get(const Evas_Object *obj,
|
|
|
|
Eina_Bool *h_bounce,
|
|
|
|
Eina_Bool *v_bounce)
|
2010-11-04 05:19:00 -07:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
ELM_PHOTOCAM_CHECK(obj);
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do((Eo *)obj, elm_interface_scrollable_bounce_allow_get(h_bounce, v_bounce));
|
2010-11-04 05:19:00 -07:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_elm_photocam_gesture_enabled_set(Eo *obj, Elm_Photocam_Data *sd, Eina_Bool gesture)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2012-07-04 14:43:29 -07:00
|
|
|
gesture = !!gesture;
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (sd->do_gesture == gesture) return;
|
|
|
|
|
|
|
|
sd->do_gesture = gesture;
|
|
|
|
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(sd->g_layer, evas_object_del);
|
2012-03-06 15:56:02 -08:00
|
|
|
|
2012-07-04 14:43:29 -07:00
|
|
|
if (!gesture) return;
|
|
|
|
|
|
|
|
sd->g_layer = elm_gesture_layer_add(obj);
|
|
|
|
if (!sd->g_layer) return;
|
|
|
|
|
|
|
|
elm_gesture_layer_attach(sd->g_layer, obj);
|
|
|
|
elm_gesture_layer_cb_set
|
|
|
|
(sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_START,
|
2012-11-25 22:32:53 -08:00
|
|
|
_g_layer_zoom_start_cb, obj);
|
2012-07-04 14:43:29 -07:00
|
|
|
elm_gesture_layer_cb_set
|
|
|
|
(sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_MOVE,
|
2012-11-25 22:32:53 -08:00
|
|
|
_g_layer_zoom_move_cb, obj);
|
2012-07-04 14:43:29 -07:00
|
|
|
elm_gesture_layer_cb_set
|
|
|
|
(sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_END,
|
2012-11-25 22:32:53 -08:00
|
|
|
_g_layer_zoom_end_cb, obj);
|
2012-07-04 14:43:29 -07:00
|
|
|
elm_gesture_layer_cb_set
|
|
|
|
(sd->g_layer, ELM_GESTURE_ZOOM, ELM_GESTURE_STATE_ABORT,
|
2012-11-25 22:32:53 -08:00
|
|
|
_g_layer_zoom_end_cb, obj);
|
2012-02-24 09:58:29 -08:00
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_elm_photocam_gesture_enabled_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *sd)
|
2012-02-24 09:58:29 -08:00
|
|
|
{
|
2014-03-25 01:49:47 -07:00
|
|
|
return sd->do_gesture;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-02-24 09:58:29 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
2014-03-25 01:49:47 -07:00
|
|
|
_elm_photocam_class_constructor(Eo_Class *klass)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
|
2015-05-05 05:16:19 -07:00
|
|
|
|
|
|
|
PHOTO_FILE_LOAD_ERROR_GENERIC = eina_error_msg_static_register("Generic load error");
|
|
|
|
PHOTO_FILE_LOAD_ERROR_DOES_NOT_EXIST = eina_error_msg_static_register("File does not exist");
|
|
|
|
PHOTO_FILE_LOAD_ERROR_PERMISSION_DENIED = eina_error_msg_static_register("Permission denied to an existing file");
|
|
|
|
PHOTO_FILE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED = eina_error_msg_static_register("Allocation of resources failure prevented load");
|
|
|
|
PHOTO_FILE_LOAD_ERROR_CORRUPT_FILE = eina_error_msg_static_register("File corrupt (but was detected as a known format)");
|
|
|
|
PHOTO_FILE_LOAD_ERROR_UNKNOWN_FORMAT = eina_error_msg_static_register("File is not a known format");
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
2014-07-25 01:33:19 -07:00
|
|
|
EOLIAN const Elm_Atspi_Action *
|
|
|
|
_elm_photocam_elm_interface_atspi_widget_action_elm_actions_get(Eo *obj EINA_UNUSED, Elm_Photocam_Data *pd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
static Elm_Atspi_Action atspi_actions[] = {
|
|
|
|
{ "move,prior", "move", "prior", _key_action_move},
|
|
|
|
{ "move,next", "move", "next", _key_action_move},
|
|
|
|
{ "move,left", "move", "left", _key_action_move},
|
|
|
|
{ "move,right", "move", "right", _key_action_move},
|
|
|
|
{ "move,up", "move", "up", _key_action_move},
|
|
|
|
{ "move,down", "move", "down", _key_action_move},
|
|
|
|
{ "zoom,in", "zoom", "in", _key_action_zoom},
|
|
|
|
{ "zoom,out", "zoom", "out", _key_action_zoom},
|
|
|
|
{ NULL, NULL, NULL, NULL }
|
|
|
|
};
|
|
|
|
return &atspi_actions[0];
|
|
|
|
}
|
|
|
|
|
2014-03-25 01:49:47 -07:00
|
|
|
#include "elm_photocam.eo.c"
|