vtorri
/
entice
1
0
Fork 0
Code Issues 8 Pull Requests Packages Projects Releases Wiki Activity
entice/src/bin/entice_image.c

691 lines
17 KiB
C
Raw Permalink Blame History

/* Entice - small and simple image viewer using the EFL
* Copyright (C) 2021 Vincent Torri
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <config.h>
#include <Elementary.h>
#include "entice_private.h"
#include "entice_config.h"
#include "entice_controls.h"
#include "entice_image.h"
#include "entice_win.h"
/*============================================================================*
* Local *
*============================================================================*/
typedef struct Img_ Img;
struct Img_
{
Evas_Object *bg;
Evas_Object *img;
Ecore_Timer *timer_anim;
int zoom;
Entice_Zoom_Mode zoom_mode;
int frame;
int frame_count;
int loops;
unsigned int loading: 1;
};
static Evas_Smart *_smart = NULL;
static Evas_Smart_Class _parent_sc = EVAS_SMART_CLASS_INIT_NULL;
static int _zoom_levels[] =
{
2,
5,
10,
20,
33,
50,
67,
100,
133,
200,
300,
400,
500,
600,
700,
800,
900,
1000,
1100,
1200,
1300,
1400,
1500,
1600,
1700,
1800,
1900,
2000
};
static Eina_Bool
_entice_image_anim_cb(void *data)
{
Img *sd;
double t;
int fr;
sd = (Img *)data;
sd->frame++;
fr = (sd->frame % (sd->frame_count)) + 1;
/* if ((sd->frame >= sd->frame_count) && (fr == 1)) */
/* { */
/* int loops; */
/* if (evas_object_image_animated_loop_type_get(sd->img) == */
/* EVAS_IMAGE_ANIMATED_HINT_NONE) */
/* { */
/* sd->timer_anim = NULL; */
/* return EINA_FALSE; */
/* } */
/* sd->loops++; */
/* loops = evas_object_image_animated_loop_count_get(sd->img); */
/* if (loops != 0) // loop == 0 -> loop forever */
/* { */
/* if (loops < sd->loops) */
/* { */
/* sd->timer_anim = NULL; */
/* return EINA_FALSE; */
/* } */
/* } */
/* } */
evas_object_image_animated_frame_set(sd->img, fr);
t = evas_object_image_animated_frame_duration_get(sd->img, fr, 0);
sd->timer_anim = ecore_timer_loop_add(t, _entice_image_anim_cb, sd);
//ecore_timer_interval_set(sd->timer_anim, t);
return EINA_FALSE;
}
static void
_entice_image_anim_handle(Img *sd)
{
double t;
if (sd->timer_anim)
ecore_timer_del(sd->timer_anim);
sd->timer_anim = NULL;
sd->frame = 0;
sd->frame_count = 0;
if (!evas_object_image_animated_get(sd->img))
return;
sd->frame_count = evas_object_image_animated_frame_count_get(sd->img);
if (sd->frame_count < 2)
return;
t = evas_object_image_animated_frame_duration_get(sd->img, sd->frame, 0);
sd->timer_anim = ecore_timer_add(t, _entice_image_anim_cb, sd);
ERR("timer duration : %f", t);
}
static void
_entice_image_preloaded(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Entice *entice;
Img *sd;
int img_w;
int img_h;
INF(" * %s", __FUNCTION__);
sd = evas_object_smart_data_get(data);
EINA_SAFETY_ON_NULL_RETURN(sd);
evas_object_smart_callback_call(data, "preloaded", NULL);
evas_object_image_size_get(sd->img, &img_w, &img_h);
if ((img_w > 0) && (img_h > 0))
evas_object_show(sd->img);
sd->loading = 0;
entice_image_update(data);
entice = evas_object_data_get(data, "entice");
if (entice->config->play_animated)
_entice_image_anim_handle(sd);
}
static void
_smart_add(Evas_Object *obj)
{
Img *sd;
INF(" * %s", __FUNCTION__);
sd = calloc(1, sizeof(Img));
EINA_SAFETY_ON_NULL_RETURN(sd);
evas_object_smart_data_set(obj, sd);
_parent_sc.add(obj);
sd->img = evas_object_image_filled_add(evas_object_evas_get(obj));
evas_object_smart_member_add(sd->img, obj);
evas_object_event_callback_add(sd->img, EVAS_CALLBACK_IMAGE_PRELOADED,
_entice_image_preloaded, obj);
sd->zoom_mode = ENTICE_ZOOM_MODE_NORMAL;
sd->zoom = 100;
}
static void
_smart_del(Evas_Object *obj)
{
Img *sd;
INF(" * %s", __FUNCTION__);
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
_parent_sc.del(obj);
evas_object_data_del(obj, "entice");
evas_object_data_del(obj, "win");
evas_object_del(sd->img);
if (sd->timer_anim) ecore_timer_del(sd->timer_anim);
evas_object_smart_data_set(obj, NULL);
memset(sd, 0, sizeof(*sd));
free(sd);
}
static void
_smart_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
{
Img *sd;
INF(" * %s", __FUNCTION__);
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
evas_object_resize(sd->img, w, h);
}
static void
_smart_show(Evas_Object *obj)
{
Img *sd;
INF(" * %s", __FUNCTION__);
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
if (!sd->loading)
evas_object_show(sd->img);
}
static void
_smart_hide(Evas_Object *obj)
{
Img *sd;
INF(" * %s", __FUNCTION__);
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
evas_object_hide(sd->img);
}
static void
_smart_calculate(Evas_Object *obj)
{
Img *sd;
Evas_Coord ox;
Evas_Coord oy;
Evas_Coord ow;
Evas_Coord oh;
INF(" * %s", __FUNCTION__);
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
evas_object_move(sd->img, ox, oy);
evas_object_resize(sd->img, ow, oh);
}
static void
_smart_init(void)
{
static Evas_Smart_Class sc;
INF(" * %s", __FUNCTION__);
evas_object_smart_clipped_smart_set(&_parent_sc);
sc = _parent_sc;
sc.name = "image";
sc.version = EVAS_SMART_CLASS_VERSION;
sc.add = _smart_add;
sc.del = _smart_del;
sc.resize = _smart_resize;
sc.show = _smart_show;
sc.hide = _smart_hide;
sc.calculate = _smart_calculate;
_smart = evas_smart_class_new(&sc);
}
static void
_entice_image_size_zoom_get(int zoom, int in_w, int in_h, int img_w, int img_h,
int *out_x, int *out_y, int *out_w, int *out_h)
{
printf("nor window : %d %d\n", in_w, in_h);
printf("nor image : %d %d\n", img_w, img_h);
printf("nor zoom : %d\n", zoom);
*out_w = (zoom * img_w) / 100;
*out_h = (zoom * img_h) / 100;
if (*out_w >= in_w)
*out_x = 0;
else
*out_x = ((in_w - *out_w) / 2);
if (*out_h >= in_h)
*out_y = 0;
else
*out_y = ((in_h - *out_h) / 2);
printf("fit out : %d %d %d %d \n", *out_x, *out_y, *out_w, *out_h);
fflush(stdout);
}
static void
_entice_image_size_fit_get(int in_w, int in_h, int img_w, int img_h,
int *out_x, int *out_y, int *out_w, int *out_h,
int *zoom)
{
printf("fit window : %d %d\n", in_w, in_h);
printf("fit image : %d %d\n", img_w, img_h);
if ((img_w <= 0) || (img_h <= 0))
{
*out_x = 0;
*out_y = 0;
*out_w = 0;
*out_h = 0;
*zoom = 100;
return;
}
if ((in_w * img_h) > (img_w * in_h))
{
*out_h = in_h;
*out_w = (img_w * in_h) / img_h;
*zoom = (100 * *out_w) / img_w;
}
else
{
*out_w = in_w;
*out_h = (img_h * in_w) / img_w;
*zoom = (100 * *out_h) / img_h;
}
*out_x = ((in_w - *out_w) / 2.0);
*out_y = ((in_h - *out_h) / 2.0);
printf("fit out : %d %d %d %d %d%%\n", *out_x, *out_y, *out_w, *out_h, *zoom);
fflush(stdout);
}
/*============================================================================*
* Global *
*============================================================================*/
Evas_Object *
entice_image_add(Evas_Object *win)
{
Evas *evas;
Evas_Object *obj;
Entice *entice;
INF(" * %s", __FUNCTION__);
EINA_SAFETY_ON_NULL_RETURN_VAL(win, NULL);
evas = evas_object_evas_get(win);
if (!evas)
{
ERR("can not get evas");
return NULL;
}
if (!_smart) _smart_init();
obj = evas_object_smart_add(evas, _smart);
evas_object_data_set(obj, "win", win);
entice = evas_object_data_get(win, "entice");
EINA_SAFETY_ON_NULL_RETURN_VAL(entice, NULL);
evas_object_data_set(obj, "entice", entice);
return obj;
}
void
entice_image_file_set(Evas_Object *obj, Eina_List *image)
{
Entice *entice;
const Entice_List_Data *data;
Img *sd;
Evas_Object *win;
Evas_Load_Error err;
INF(" * %s", __FUNCTION__);
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
win = evas_object_data_get(obj, "win");
EINA_SAFETY_ON_NULL_RETURN(win);
entice = evas_object_data_get(obj, "entice");
EINA_SAFETY_ON_NULL_RETURN(entice);
if (!image)
{
elm_object_signal_emit(entice->layout, "state,error,show", "entice");
elm_win_title_set(win, "Entice");
return;
}
if (image == entice->image_current)
return;
entice->image_current = image;
if (sd->timer_anim)
ecore_timer_del(sd->timer_anim);
sd->timer_anim = NULL;
sd->frame = 0;
sd->frame_count = 0;
sd->loading = 0;
evas_object_hide(sd->img);
evas_object_image_file_set(sd->img, NULL, NULL);
evas_object_image_load_head_skip_set(sd->img, EINA_TRUE);
evas_object_image_load_orientation_set(sd->img,
entice->config->automatic_orientation);
data = (const Entice_List_Data *)eina_list_data_get(entice->image_current);
INF(" * %s : %s", __FUNCTION__, data->path);
evas_object_image_file_set(sd->img, data->path, NULL);
err = evas_object_image_load_error_get(sd->img);
if (err != EVAS_LOAD_ERROR_NONE)
{
ERR("Could not load image '%s' : \"%s\"\n",
data->path, evas_load_error_str(err));
ERR("Verify that the Evas loader is available for this image if you think it is a valid image");
return;
}
sd->loading = 1;
evas_object_image_preload(sd->img, EINA_FALSE);
if (entice->config->best_fit_startup)
sd->zoom_mode = ENTICE_ZOOM_MODE_FIT;
/* if (entice->config->play_animated) */
/* _entice_image_anim_handle(sd); */
}
const char *
entice_image_file_get(Evas_Object *obj)
{
Img *sd;
const char *filename;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN_VAL(sd, NULL);
evas_object_image_file_get(sd->img, &filename, NULL);
return filename;
}
void
entice_image_size_get(Evas_Object *obj, int *w, int *h)
{
Img *sd;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
evas_object_image_size_get(sd->img, w, h);
}
void
entice_image_rotate(Evas_Object *obj, unsigned int rot)
{
Img *sd;
Evas_Image_Orient orient;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
INF(" * %s : %d", __FUNCTION__, rot);
orient = evas_object_image_orient_get(sd->img) + rot;
evas_object_image_orient_set(sd->img, orient & 3);
if (sd->zoom_mode == ENTICE_ZOOM_MODE_FIT)
entice_image_update(obj);
}
void
entice_image_zoom_mode_set(Evas_Object *obj, Entice_Zoom_Mode zoom_mode)
{
Img *sd;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
INF(" * %s : %d", __FUNCTION__, zoom_mode);
sd->zoom_mode = zoom_mode;
}
Entice_Zoom_Mode
entice_image_zoom_mode_get(Evas_Object *obj)
{
Img *sd;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN_VAL(sd, ENTICE_ZOOM_MODE_NORMAL);
return sd->zoom_mode;
}
void entice_image_zoom_set(Evas_Object *obj, int zoom)
{
Img *sd;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
INF(" * %s : %d", __FUNCTION__, zoom);
sd->zoom_mode = ENTICE_ZOOM_MODE_NORMAL;
sd->zoom = zoom;
}
int entice_image_zoom_get(Evas_Object *obj)
{
Img *sd;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN_VAL(sd, 100);
return sd->zoom;
}
void
entice_image_zoom_increase(Evas_Object *obj)
{
Img *sd;
size_t l;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
INF(" * %s", __FUNCTION__);
l = sizeof(_zoom_levels) / sizeof(int);
for (size_t i = 0; i < (l - 1); i++)
{
if ((_zoom_levels[i] <= sd->zoom) && (sd->zoom < _zoom_levels[i + 1]))
{
entice_image_zoom_set(obj, _zoom_levels[i + 1]);
break;
}
}
}
void
entice_image_zoom_decrease(Evas_Object *obj)
{
Img *sd;
size_t l;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
INF(" * %s", __FUNCTION__);
l = sizeof(_zoom_levels) / sizeof(int);
for (size_t i = (l - 1); i > 0; i--)
{
if ((_zoom_levels[i - 1] < sd->zoom) && (sd->zoom <= _zoom_levels[i]))
{
entice_image_zoom_set(obj, _zoom_levels[i - 1]);
break;
}
}
}
void
entice_image_update(Evas_Object *obj)
{
Evas_Object *win;
Entice *entice;
Img *sd;
Evas_Coord win_w;
Evas_Coord win_h;
Evas_Coord img_w;
Evas_Coord img_h;
Evas_Coord out_x;
Evas_Coord out_y;
Evas_Coord out_w;
Evas_Coord out_h;
int zoom;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN(sd);
win = evas_object_data_get(obj, "win");
EINA_SAFETY_ON_NULL_RETURN(win);
entice = evas_object_data_get(win, "entice");
EINA_SAFETY_ON_NULL_RETURN(entice);
INF("loading: %d (%p)", sd->loading, sd->img);
if (!sd->loading)
{
evas_object_geometry_get(win, NULL, NULL, &win_w, &win_h);
evas_object_image_size_get(sd->img, &img_w, &img_h);
INF("size: [%d] %d x %d", sd->zoom_mode, img_w, img_h);
switch (sd->zoom_mode)
{
case ENTICE_ZOOM_MODE_NORMAL:
_entice_image_size_zoom_get(sd->zoom, win_w, win_h, img_w, img_h,
&out_x, &out_y, &out_w, &out_h);
elm_scroller_policy_set(entice->scroller,
ELM_SCROLLER_POLICY_AUTO,
ELM_SCROLLER_POLICY_AUTO);
break;
case ENTICE_ZOOM_MODE_FIT:
_entice_image_size_fit_get(win_w, win_h, img_w, img_h,
&out_x, &out_y, &out_w, &out_h, &zoom);
sd->zoom = zoom;
elm_scroller_policy_set(entice->scroller,
ELM_SCROLLER_POLICY_OFF,
ELM_SCROLLER_POLICY_OFF);
break;
}
INF("zoom %d", sd->zoom);
evas_object_resize(obj, out_w, out_h);
evas_object_size_hint_max_set(obj, out_w, out_h);
evas_object_size_hint_min_set(obj, out_w, out_h);
evas_object_move(sd->img, out_x, out_y);
entice_win_title_update(win);
entice_controls_update(win);
}
}
char *
entice_image_title_get(Evas_Object *obj)
{
char buf[1024];
Img *sd;
int w;
int h;
sd = evas_object_smart_data_get(obj);
EINA_SAFETY_ON_NULL_RETURN_VAL(sd, NULL);
entice_image_size_get(obj, &w, &h);
snprintf(buf, sizeof(buf), "%s (%d x %d) %d%%",
ecore_file_file_get(entice_image_file_get(obj)), w, h,
entice_image_zoom_get(obj));
return strdup(buf);
}
Reference in New Issue View Git Blame Copy Permalink