EAPI Eina_Bool
emotion_object_file_set(Evas_Object *obj, const char *file)
{
Smart_Data *sd;
E_SMART_OBJ_GET_RETURN(sd, obj, E_OBJ_NAME, EINA_FALSE);
DBG("file=%s", file);
if (!eina_stringshare_replace(&sd->file, file))
return EINA_TRUE;
if (!sd->engine_instance)
{
WRN("No engine choosen. Call emotion_object_init()?");
return EINA_FALSE;
}
sd->video.w = 0;
sd->video.h = 0;
if ((file) && (file[0] != 0))
{
eina_stringshare_replace(&sd->file, file);
emotion_engine_instance_file_close(sd->engine_instance);
evas_object_image_data_set(sd->obj, NULL);
evas_object_image_size_set(sd->obj, 1, 1);
_emotion_image_data_zero(sd->obj);
sd->open = 0;
if (!emotion_engine_instance_file_open(sd->engine_instance, sd->file))
{
WRN("Couldn't open file=%s", sd->file);
return EINA_FALSE;
}
DBG("successfully opened file=%s", sd->file);
sd->pos = 0.0;
if (sd->play) emotion_engine_instance_play(sd->engine_instance, 0.0);
}
else
{
emotion_engine_instance_file_close(sd->engine_instance);
evas_object_image_data_set(sd->obj, NULL);
evas_object_image_size_set(sd->obj, 1, 1);
_emotion_image_data_zero(sd->obj);
eina_stringshare_replace(&sd->file, NULL);
}
if (sd->anim) ecore_animator_del(sd->anim);
sd->anim = NULL;
#ifdef HAVE_EIO
/* Only cancel the load_xattr or we will loose ref to time_seek stringshare */
if (sd->load_xattr) eio_file_cancel(sd->load_xattr);
sd->load_xattr = NULL;
if (sd->save_xattr) eio_file_cancel(sd->save_xattr);
sd->save_xattr = NULL;
#endif
return EINA_TRUE;
}
void _eyelight_viewer_slideshow_slides_load(Eyelight_Viewer* pres)
{
int i;
Evas_Object *o_image;
char buf[EYELIGHT_BUFLEN];
int nb_slides = pres->slideshow_nb_slides;
int first_slide = pres->slideshow_current - (nb_slides/2);
if(!pres->slideshow_image_thumbnails)
pres->slideshow_image_thumbnails = calloc(nb_slides,sizeof(Evas_Object*));
for(i=0;i<nb_slides; i++)
{
if(first_slide+i<0 || i+first_slide>=pres->size)
{
snprintf(buf,EYELIGHT_BUFLEN,"slideshow,slide,hide,%d",i+1);
edje_object_signal_emit(pres->slideshow_background,
buf,"eyelight");
}
else
{
snprintf(buf,EYELIGHT_BUFLEN,"slideshow,slide,show,%d",i+1);
edje_object_signal_emit(pres->slideshow_background,
buf,"eyelight");
if(!pres->slideshow_image_thumbnails[i])
{
const Eyelight_Thumb* thumb = eyelight_viewer_thumbnails_get(pres,first_slide+i);
o_image = evas_object_image_add(pres->evas);
pres->slideshow_image_thumbnails[i] = o_image;
if (thumb->thumb)
{
evas_object_image_size_set(o_image, thumb->w, thumb->h);
evas_object_image_data_set(o_image,thumb->thumb);
evas_object_image_filled_set(o_image,1);
}
else
{
char key[256];
int w;
int h;
snprintf(key, sizeof (key), "eyelight/thumb/%i", thumb->pos);
evas_object_image_file_set(o_image, pres->dump_in, key);
evas_object_image_size_get(o_image, &w, &h);
evas_object_image_fill_set(o_image, 0, 0, w, h);
}
evas_object_show(o_image);
snprintf(buf,EYELIGHT_BUFLEN,"object.swallow_%d",i+1);
edje_object_part_swallow(pres->slideshow_background,buf,o_image);
}
}
}
eyelight_viewer_thumbnails_clean(pres,first_slide,first_slide+nb_slides);
}
void
_icon_editor_gui_update()
{
char *tmp;
Evas_Object *im_obj;
void *im_data = NULL;
int im_w = 0, im_h = 0;
tmp = icon_editor_exec_get();
ewl_entry_text_set(EWL_ENTRY(editor->exec.entry), tmp);
free(tmp);
/* FIXME: set the name */
im_obj = EWL_IMAGE(editor->icon_image)->image;
icon_editor_image_data_get(&im_data, &im_w, &im_h);
if (!im_data) return;
evas_object_image_size_set(im_obj, im_w, im_h);
evas_object_image_data_copy_set(im_obj, im_data);
evas_object_image_alpha_set(im_obj, 1);
evas_object_image_data_update_add(im_obj, 0, 0, im_w, im_h);
evas_object_image_fill_set(im_obj, 0, 0, im_w, im_h);
printf("wxh: %d x %d\n", im_w, im_h);
ewl_object_size_request(EWL_OBJECT(editor->icon_image), im_w, im_h);
ewl_object_maximum_size_set(EWL_OBJECT(editor->icon_image), im_w, im_h);
ewl_object_minimum_size_set(EWL_OBJECT(editor->icon_image), im_w, im_h);
}
static void
win_resize_cb(void *data, Evas *e , Evas_Object *obj , void *event_info)
{
appdata_s *ad = data;
if(ad->evas_gl_surface)
{
cairo_surface_destroy(ad->surface);
cairo_destroy(ad->cairo);
cairo_device_destroy(ad->cairo_device);
evas_gl_surface_destroy(ad->evas_gl, ad->evas_gl_surface);
ad->evas_gl_surface = NULL;
}
evas_object_geometry_get(obj, NULL, NULL, &ad->width, &ad->height);
evas_object_image_size_set(ad->img, ad->width, ad->height);
evas_object_resize(ad->img, ad->width, ad->height);
evas_object_show(ad->img);
if(!ad->evas_gl_surface)
{
Evas_Native_Surface ns;
ad->evas_gl_surface = evas_gl_surface_create(ad->evas_gl, ad->evas_gl_config, ad->width, ad->height);
evas_gl_native_surface_get(ad->evas_gl, ad->evas_gl_surface, &ns);
evas_object_image_native_surface_set(ad->img, &ns);
evas_object_image_pixels_dirty_set (ad->img, EINA_TRUE);
ad->cairo_device = (cairo_device_t *)cairo_evas_gl_device_create (ad->evas_gl, ad->evas_gl_context);
cairo_gl_device_set_thread_aware(ad->cairo_device, 0);
ad->surface = (cairo_surface_t *)cairo_gl_surface_create_for_evas_gl(ad->cairo_device, ad->evas_gl_surface, ad->evas_gl_config, ad->width, ad->height);
ad->cairo = cairo_create (ad->surface);
}
}
static int
EvasResetMainloopCb( vout_display_t *vd )
{
vout_display_sys_t *sys = vd->sys;
if( sys->b_evas_changed )
return -1;
if( sys->p_anim )
{
ecore_animator_del( sys->p_anim );
sys->p_anim = NULL;
}
evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_IMAGE_RESIZE,
EvasResizeCb, vd );
FmtUpdate( vd );
evas_object_image_data_set( sys->p_evas, NULL );
evas_object_image_size_set( sys->p_evas, sys->i_width, sys->i_height );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_IMAGE_RESIZE,
EvasResizeCb, vd );
return 0;
}
PassRefPtr<Evas_Object> evasObjectFromCairoImageSurface(Evas* canvas, cairo_surface_t* surface)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(surface, 0);
cairo_status_t status = cairo_surface_status(surface);
if (status != CAIRO_STATUS_SUCCESS) {
EINA_LOG_ERR("cairo surface is invalid: %s", cairo_status_to_string(status));
return 0;
}
cairo_surface_type_t type = cairo_surface_get_type(surface);
if (type != CAIRO_SURFACE_TYPE_IMAGE) {
EINA_LOG_ERR("unknown surface type %d, required %d (CAIRO_SURFACE_TYPE_IMAGE).",
type, CAIRO_SURFACE_TYPE_IMAGE);
return 0;
}
cairo_format_t format = cairo_image_surface_get_format(surface);
if (format != CAIRO_FORMAT_ARGB32 && format != CAIRO_FORMAT_RGB24) {
EINA_LOG_ERR("unknown surface format %d, expected %d or %d.",
format, CAIRO_FORMAT_ARGB32, CAIRO_FORMAT_RGB24);
return 0;
}
int width = cairo_image_surface_get_width(surface);
int height = cairo_image_surface_get_height(surface);
int stride = cairo_image_surface_get_stride(surface);
if (width <= 0 || height <= 0 || stride <= 0) {
EINA_LOG_ERR("invalid image size %dx%d, stride=%d", width, height, stride);
return 0;
}
void* data = cairo_image_surface_get_data(surface);
if (!data) {
EINA_LOG_ERR("could not get source data.");
return 0;
}
RefPtr<Evas_Object> image = adoptRef(evas_object_image_filled_add(canvas));
if (!image) {
EINA_LOG_ERR("could not add image to canvas.");
return 0;
}
evas_object_image_colorspace_set(image.get(), EVAS_COLORSPACE_ARGB8888);
evas_object_image_size_set(image.get(), width, height);
evas_object_image_alpha_set(image.get(), format == CAIRO_FORMAT_ARGB32);
if (evas_object_image_stride_get(image.get()) != stride) {
EINA_LOG_ERR("evas' stride %d diverges from cairo's %d.",
evas_object_image_stride_get(image.get()), stride);
return 0;
}
evas_object_image_data_copy_set(image.get(), data);
return image.release();
}
/**
* @internal
*
* This function takes actual shot and saves it in PNG
* @param data Tsuite_Data pointer initiated by user
* @param obj Window pointer
* @param obj name file name. Will use name_+serial if NULL
*
* @ingroup Tsuite
*/
void
tsuite_shot_do(char *name, Evas *e)
{
if (!e)
return;
Ecore_Evas *ee, *ee_orig;
Evas_Object *o;
unsigned int *pixels;
int w, h,dir_name_len = 0;
char *filename;
if (_hook_setting->dest_dir)
dir_name_len = strlen(_hook_setting->dest_dir) + 1; /* includes space of a '/' */
if (name)
{
filename = malloc(strlen(name) + strlen(IMAGE_FILENAME_EXT) +
dir_name_len + 4);
if (_hook_setting->dest_dir)
sprintf(filename, "%s/", _hook_setting->dest_dir);
sprintf(filename + dir_name_len, "%s%s", name, IMAGE_FILENAME_EXT);
}
else
{
filename = malloc(strlen(_hook_setting->test_name) + strlen(IMAGE_FILENAME_EXT) +
dir_name_len + 8); /* also space for serial */
ts.serial++;
if (_hook_setting->dest_dir)
sprintf(filename, "%s/", _hook_setting->dest_dir);
sprintf(filename + dir_name_len, "%s_%d%s", _hook_setting->test_name,
ts.serial, IMAGE_FILENAME_EXT);
}
ee_orig = ecore_evas_ecore_evas_get(e);
ecore_evas_manual_render(ee_orig);
pixels = (void *)ecore_evas_buffer_pixels_get(ee_orig);
if (!pixels) return;
ecore_evas_geometry_get(ee_orig, NULL, NULL, &w, &h);
if ((w < 1) || (h < 1)) return;
ee = ecore_evas_buffer_new(1, 1);
o = evas_object_image_add(ecore_evas_get(ee));
evas_object_image_alpha_set(o, ecore_evas_alpha_get(ee_orig));
evas_object_image_size_set(o, w, h);
evas_object_image_data_set(o, pixels);
if (!evas_object_image_save(o, filename, NULL, NULL))
{
printf("Cannot save widget to <%s>\n", filename);
}
ecore_evas_free(ee);
free(filename);
}
EAPI void
e_icon_data_set(Evas_Object *obj, void *data, int w, int h)
{
E_Smart_Data *sd;
if (evas_object_smart_smart_get(obj) != _e_smart) SMARTERRNR();
if (!(sd = evas_object_smart_data_get(obj))) return;
if (sd->edje) return;
evas_object_image_size_set(sd->obj, w, h);
evas_object_image_data_copy_set(sd->obj, data);
}
EAPI void
e_icon_data_set(Evas_Object *obj, void *data, int w, int h)
{
E_Smart_Data *sd;
sd = evas_object_smart_data_get(obj);
if (!sd) return;
if (!strcmp(evas_object_type_get(sd->obj), "edje"))
return;
evas_object_image_size_set(sd->obj, w, h);
evas_object_image_data_copy_set(sd->obj, data);
}
void
eps_page_render (const Eps_Page *page,
Evas_Object *o)
{
unsigned char *data;
unsigned char *d;
unsigned int *m = NULL;
double hscale;
double vscale;
SpectreStatus status;
int width;
int height;
int stride;
int yy;
if (!page || !o)
return;
spectre_page_render (page->page, page->rc,
&data, &stride);
status = spectre_page_status (page->page);
if (status != SPECTRE_STATUS_SUCCESS) {
printf ("[eps] %s\n", spectre_status_to_string (status));
return;
}
eps_page_scale_get (page, &hscale, &vscale);
eps_page_size_get (page, &width, &height);
width *= hscale;
height *= vscale;
evas_object_image_size_set (o, width, height);
evas_object_image_fill_set (o, 0, 0, width, height);
m = (unsigned int *)evas_object_image_data_get (o, 1);
if (!m) {
free (data);
return;
}
if (stride == 4 * width)
memcpy(m, data, height * stride);
else {
d = data;
for (yy = 0; yy < height; d += stride, m += width, ++yy) {
memcpy (m, d, width * 4);
}
}
evas_object_image_data_update_add (o, 0, 0, width, height);
evas_object_resize (o, width, height);
free (data);
}
void
eps_page_render_slice (const Eps_Page *page,
Evas_Object *o,
int x,
int y,
int width,
int height)
{
unsigned char *data;
unsigned char *d;
unsigned int *m = NULL;
double hscale;
double vscale;
SpectreStatus status;
int stride;
int yy;
if (!page || !o || (width <= 0) || (height <= 0))
return;
spectre_page_render_slice (page->page, page->rc,
x, y, width, height,
&data, &stride);
status = spectre_page_status (page->page);
if (status != SPECTRE_STATUS_SUCCESS) {
printf ("aie !!%d %d %d %d %d\n", status, x, y, width, height);
printf ("[eps] %s\n", spectre_status_to_string (status));
return;
}
eps_page_scale_get (page, &hscale, &vscale);
width *= hscale;
height *= vscale;
evas_object_image_size_set (o, width, height);
evas_object_image_fill_set (o, 0, 0, width, height);
m = (unsigned int *)evas_object_image_data_get (o, 1);
if (!m) {
free (data);
return;
}
d = data + y * stride + x;
for (yy = 0; yy < height; d += stride, m += width, ++yy) {
memcpy (m, d, width * 4);
}
evas_object_image_data_update_add (o, 0, 0, width, height);
evas_object_resize (o, width, height);
free (data);
}
/* local subsystem functions */
static void
_win_unredirect(E_Comp_Win *cw)
{
E_CHECK(cw);
E_CHECK(cw->visible);
E_CHECK(!(cw->input_only));
E_CHECK(!(cw->invalid));
if (cw->obj)
{
evas_object_hide(cw->obj);
evas_object_del(cw->obj);
cw->obj = NULL;
}
if (cw->update_timeout)
{
ecore_timer_del(cw->update_timeout);
cw->update_timeout = NULL;
}
if (cw->native)
{
evas_object_image_native_surface_set(cw->obj, NULL);
cw->native = 0;
}
if (cw->pixmap)
{
ecore_x_pixmap_free(cw->pixmap);
cw->pixmap = 0;
cw->pw = 0;
cw->ph = 0;
}
if (cw->xim)
{
evas_object_image_size_set(cw->obj, 1, 1);
evas_object_image_data_set(cw->obj, NULL);
ecore_x_image_free(cw->xim);
cw->xim = NULL;
}
if (cw->redirected)
{
ecore_x_composite_unredirect_window
(cw->win, ECORE_X_COMPOSITE_UPDATE_MANUAL);
cw->redirected = 0;
}
if (cw->damage)
{
e_mod_comp_win_del_damage(cw, cw->damage);
ecore_x_damage_subtract(cw->damage, 0, 0);
ecore_x_damage_free(cw->damage);
cw->damage = 0;
}
}
Etheme_Object * etheme_new(const char * t) {
Etheme_Object * o;
o = (Etheme_Object *) malloc(sizeof(Etheme_Object));
o->theme = (char *) strdup(t);
o->thumbpath = e_preview_thumb_file_get(t);
int size = strlen(t) - 4; /* without .edj */
o->label = malloc(sizeof(char) * size);
o->label = strncpy(o->label, t, size);
o->label[size] = 0;
o->button = edje_object_add(evas);
edje_object_file_set(o->button, default_theme, "fileman/icon_normal");
evas_object_resize(o->button, 100, 120);
edje_object_part_text_set(o->button, "icon_title" , o->label);
esmart_container_element_append(container, o->button);
if (e_preview_thumb_check(t))
e_preview_thumb_generate(t);
o->thumb = evas_object_image_add(evas);
evas_object_image_size_set(o->thumb, 640, 480);
evas_object_image_fill_set(o->thumb, 0, 0, 85, 85);
e_preview_thumb_image(o->thumbpath, o->thumb);
edje_object_part_swallow(o->button, "icon_swallow", o->thumb);
evas_object_show(o->button);
edje_object_signal_callback_add(o->button, "mouse,up,1", "icon_event",
_preview_theme, o);
return o;
}
static void _ewk_view_single_smart_resize(Evas_Object *o, Evas_Coord w, Evas_Coord h)
{
Ewk_View_Smart_Data *sd = (Ewk_View_Smart_Data*)evas_object_smart_data_get(o);
_parent_sc.sc.resize(o, w, h);
// these should be queued and processed in calculate as well!
evas_object_image_size_set(sd->backing_store, w, h);
if (sd->animated_zoom.zoom.current < 0.00001) {
Evas_Object *clip = evas_object_clip_get(sd->backing_store);
Evas_Coord x, y, cw, ch;
evas_object_image_fill_set(sd->backing_store, 0, 0, w, h);
evas_object_geometry_get(sd->backing_store, &x, &y, 0, 0);
evas_object_move(clip, x, y);
ewk_frame_contents_size_get(sd->main_frame, &cw, &ch);
if (w > cw)
w = cw;
if (h > ch)
h = ch;
evas_object_resize(clip, w, h);
}
}
static Evas_Object* differenceImageFromDifferenceBuffer(Evas* evas, unsigned char* buffer, int width, int height)
{
Evas_Object* image = evas_object_image_filled_add(evas);
if (!image)
abortWithErrorMessage("could not create difference image");
evas_object_image_size_set(image, width, height);
evas_object_image_colorspace_set(image, EVAS_COLORSPACE_ARGB8888);
unsigned char* diffPixels = static_cast<unsigned char*>(evas_object_image_data_get(image, EINA_TRUE));
const int rowStride = evas_object_image_stride_get(image);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
unsigned char* diffPixel = pixelFromImageData(diffPixels, rowStride, x, y);
diffPixel[Red] = diffPixel[Green] = diffPixel[Blue] = *buffer++;
diffPixel[Alpha] = 0xff;
}
}
evas_object_image_data_set(image, diffPixels);
return image;
}
static int
EvasInitMainloopCb( vout_display_t *vd )
{
vout_display_sys_t *sys = vd->sys;
#ifdef HAVE_TIZEN_SDK
if( !EvasIsOpenGLSupported( vd ) || TbmSurfaceSetup( vd ) )
#endif
if( EvasImageSetup( vd ) )
return -1;
evas_object_image_alpha_set( sys->p_evas, 0 );
evas_object_image_size_set( sys->p_evas, sys->i_width, sys->i_height );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_MOUSE_DOWN,
EventMouseDownCb, vd );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_MOUSE_UP,
EvasMouseUpCb, vd );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_MOUSE_MOVE,
EvasMouseMoveCb, vd );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_MULTI_DOWN,
EvasMultiDownCb, vd );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_MULTI_UP,
EvasMultiUpCb, vd );
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_MULTI_MOVE,
EvasMultiMoveCb, vd );
#ifdef HAVE_EVAS_CALLBACK_KEY_UP
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_KEY_UP,
EvasKeyUpCb, sys );
#endif
evas_object_event_callback_add( sys->p_evas, EVAS_CALLBACK_IMAGE_RESIZE,
EvasResizeCb, vd );
return 0;
}
static void _ewk_view_single_smart_resize(Evas_Object* ewkView, Evas_Coord width, Evas_Coord height)
{
Ewk_View_Smart_Data* smartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(ewkView));
_parent_sc.sc.resize(ewkView, width, height);
if (!smartData)
return;
// these should be queued and processed in calculate as well!
evas_object_image_size_set(smartData->backing_store, width, height);
if (smartData->animated_zoom.zoom.current < 0.00001) {
Evas_Object* clip = evas_object_clip_get(smartData->backing_store);
Evas_Coord x, y, cw, ch;
evas_object_image_fill_set(smartData->backing_store, 0, 0, width, height);
evas_object_geometry_get(smartData->backing_store, &x, &y, 0, 0);
evas_object_move(clip, x, y);
ewk_frame_contents_size_get(smartData->main_frame, &cw, &ch);
if (width > cw)
width = cw;
if (height > ch)
height = ch;
evas_object_resize(clip, width, height);
}
}
void
esmart_dvi_render (Evas_Object *obj)
{
Smart_Dvi *sp;
E_SMART_OBJ_GET (sp, obj, E_OBJ_NAME);
if (!sp->filename) return;
if (sp->dvi_document)
{
if (sp->dvi_page)
edvi_page_delete (sp->dvi_page);
if (sp->obj)
{
unsigned int *m;
int w;
int h;
sp->dvi_page = edvi_page_new (sp->dvi_document);
edvi_page_size_get (sp->dvi_page, &w, &h);
evas_object_image_size_set (sp->obj, w, h);
evas_object_image_fill_set (sp->obj, 0, 0, w, h);
m = (unsigned int *)evas_object_image_data_get (sp->obj, 1);
if (!m)
return;
memset(m, (255 << 24) | (255 << 16) | (255 << 8) | 255, w * h * 4);
evas_object_image_data_update_add (sp->obj, 0, 0, w, h);
evas_object_resize (sp->obj, w, h);
edvi_page_render (sp->dvi_page, sp->dvi_device, sp->obj);
}
evas_object_show (sp->obj);
}
}
static void
compiz_render_resize(Compiz_GL *cgl)
{
evas_object_geometry_set(cgl->obj, 0, 0, e_comp->w, e_comp->h);
evas_object_image_size_set(cgl->obj, e_comp->w, e_comp->h);
}
int captureScreen()
{
char dstpath[MAX_PATH_LENGTH];
char* scrimage;
int width, height;
Evas* ev = NULL;
Evas_Object* img;
screenshot_data sdata;
probeInfo_t probeInfo;
int ret = 0;
static pthread_mutex_t captureScreenLock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&captureScreenLock);
probeBlockStart();
setProbePoint(&probeInfo);
sdata.ximage = NULL;
scrimage = captureScreenShotX(&width, &height, &sdata);
if(scrimage != NULL)
{
ev = create_canvas(width, height);
if(likely(ev != NULL))
{
snprintf(dstpath, sizeof(dstpath),
SCREENSHOT_DIRECTORY "/%d_%d.png", getpid(),
probeInfo.eventIndex);
// make image buffer
if((img = evas_object_image_add(ev)) != NULL)
{
//image buffer set
evas_object_image_data_set(img, NULL);
evas_object_image_size_set(img, width, height);
evas_object_image_data_set(img, scrimage);
// resize image
if(height > MAX_HEIGHT)
{
width = width * MAX_HEIGHT / height;
height = MAX_HEIGHT;
evas_object_resize(img, width, height);
evas_object_image_fill_set(img, 0, 0, width, height);
}
evas_object_image_data_update_add(img, 0, 0, width, height);
//save file
if(evas_object_image_save(img, dstpath, NULL, "compress=5") != 0)
{
chmod(dstpath, 0777);
/* welcome to the hell */
log_t log;
PREPARE_LOCAL_BUF_THOUGH((char *)&log);
/* skip header */
LOCAL_BUF += offsetof(log_t, data);
/* pack screenshot name */
BUF_PTR = pack_string(LOCAL_BUF, dstpath); /* file name */
LOCAL_BUF = BUF_PTR;
/* pack probe */
PACK_COMMON_BEGIN(MSG_PROBE_SCREENSHOT, API_ID_captureScreen, "", 0);
PACK_COMMON_END('d', 0, 0, 0);
PACK_SCREENSHOT(dstpath, getOrientation());
SET_MSG_LEN();
log.length = GET_MSG_LEN() + MSG_LEN_OFFSET + strlen(dstpath) + 1;
/* send all message */
printLog(&log, MSG_IMAGE);
}
else
{
// captureScreen : evas_object_image_save failed
ret = -1;
}
}
else
{
// captureScreen : evas_object_image_add failed
ret = -1;
}
}
else
{
// captureScreen : create canvas failed
ret = -1;
}
}
else
{
// captureScreen : captureScreenShotX failed
ret = -1;
}
// release resources
releaseScreenShotX(&sdata);
if(ev)
destroy_canvas(ev);
probeBlockEnd();
pthread_mutex_unlock(&captureScreenLock);
return ret;
}
void
epdf_page_render (Epdf_Page *page, Evas_Object *o)
{
SplashOutputDev *output_dev;
SplashColor white;
SplashColorPtr color_ptr;
Epdf_Document *doc;
unsigned int *m = NULL;
double hscale;
double vscale;
int rotate;
int width;
int height;
double t1,t2;
t1 = ecore_time_get();
white[0] = 255;
white[1] = 255;
white[2] = 255;
white[3] = 255;
if (!page->page || !page->page->isOk ())
return;
doc = page->doc;
output_dev = new SplashOutputDev(splashModeXBGR8, 4, gFalse, white);
output_dev->startDoc(doc->pdfdoc->getXRef ());
switch (page->orientation) {
case EPDF_PAGE_ORIENTATION_LANDSCAPE:
rotate = 90;
break;
case EPDF_PAGE_ORIENTATION_UPSIDEDOWN:
rotate = 180;
break;
case EPDF_PAGE_ORIENTATION_SEASCAPE:
rotate = 270;
break;
case EPDF_PAGE_ORIENTATION_PORTRAIT:
default:
rotate = 0;
break;
}
epdf_page_scale_get (page, &hscale, &vscale);
page->page->display (output_dev,
72.0 * hscale,
72.0 * vscale,
rotate,
false, false, false,
doc->pdfdoc->getCatalog ());
color_ptr = output_dev->getBitmap ()->getDataPtr ();
width = output_dev->getBitmap()->getWidth();
height = output_dev->getBitmap()->getHeight();
evas_object_image_size_set(o, width, height);
evas_object_image_fill_set(o, 0, 0, width, height);
m = (unsigned int *)evas_object_image_data_get(o, 1);
if (!m)
goto sortie;
memcpy (m, color_ptr, height * width * 4);
evas_object_image_data_set(o, m);
evas_object_image_data_update_add(o, 0, 0, width, height);
evas_object_resize(o, width, height);
// evas_object_image_alpha_set (o, 0);
sortie:
delete output_dev;
t2 = ecore_time_get();
printf ("time poppler: %f\n", t2-t1);
}
void utils_slide_delete(List_Item *item)
{
int i = 0;
Eina_List *l;
List_Item *_item;
EINA_LIST_FOREACH(l_slides, l, _item)
{
if(item == _item)
break;
else
i++;
}
Evas_Object *lbl, *tb, *bt, *icon;
char buf[PATH_MAX];
snprintf(buf, sizeof(buf), "%s/theme.edj", PACKAGE_DATA_DIR);
_inwin_delete_slide = elm_win_inwin_add(win);
evas_object_show(_inwin_delete_slide);
elm_object_style_set(_inwin_delete_slide, "minimal");
tb = elm_table_add(win);
elm_win_inwin_content_set(_inwin_delete_slide, tb);
//icon
icon = edje_object_add(evas_object_evas_get(win));
edje_object_file_set(icon, buf, "list/slides/icon");
evas_object_size_hint_min_set(icon,1024*0.20,768*0.20);
evas_object_size_hint_max_set(icon,1024*0.20,768*0.20);
if(item->thumb)
{
int w = item->thumb->w;
int h = item->thumb->h;
int *image = calloc(w*h, sizeof(int));
memcpy(image, item->thumb->thumb, sizeof(int)*w*h);
const Evas_Object *o_image = edje_object_part_object_get(icon, "object.icon");
evas_object_image_filled_set((Evas_Object*)o_image,1);
evas_object_color_set((Evas_Object*)o_image,255,255,255,255);
evas_object_image_size_set((Evas_Object*)o_image, w, h);
evas_object_image_data_set((Evas_Object*)o_image, image);
edje_object_signal_emit(icon, "icon,show", "eyelight");
}
evas_object_show(icon);
elm_table_pack(tb, icon, 0, 0, 2, 1);
//
bt= elm_button_add(win);
elm_object_text_set(bt, "Invisible button to add a vertical space");
elm_table_pack(tb, bt, 0, 1, 1, 1);
lbl = elm_label_add(win);
elm_object_text_set(lbl, D_("Are you sure you want to delete this slide ?"));
elm_table_pack(tb, lbl, 0, 2, 2, 1);
evas_object_show(lbl);
bt= elm_button_add(win);
elm_object_text_set(bt, "Invisible button to add a vertical space");
elm_table_pack(tb, bt, 0, 3, 1, 1);
bt= elm_button_add(win);
elm_object_text_set(bt, D_("Yes, Delete the slide"));
evas_object_smart_callback_add(bt, "clicked", _utils_slide_delete_cb, item);
evas_object_color_set(bt, 255, 0, 0, 255);
elm_table_pack(tb, bt, 0, 4, 1, 1);
evas_object_show(bt);
bt= elm_button_add(win);
elm_object_text_set(bt, D_("No, do not delete the slide"));
evas_object_smart_callback_add(bt, "clicked", _utils_slide_delete_cancel_cb, item);
elm_table_pack(tb, bt, 1, 4, 1, 1);
evas_object_show(bt);
}
bool EflResources::copyResource( Evas_Object* const _image
, std::string const& _path
, bool const _keep_aspect
, int _width
, int _height ) const
{
bool result( true );
Evas_Object* object = nullptr;
if( 0 != preloaded_images__.count( _path ) )
object = preloaded_images__.find( _path )->second;
else
{
object = preloaded_images__.find( IMG_DIR "/placeholder.png" )->second;
LOGGER( "Could not find file among preloaded images: " + _path );
result = false;
}
int src_w = 0;
int src_h = 0;
evas_object_image_size_get( object
, &src_w
, &src_h );
evas_object_image_size_set( _image
, src_w
, src_h );
evas_object_image_alpha_set( _image
, evas_object_image_alpha_get( object ) );
evas_object_image_data_set( _image
, evas_object_image_data_get( object
, 0 ) );
if( _keep_aspect )
{
if( 0 == _width || 0 == _height )
{
evas_object_geometry_get( _image
, nullptr
, nullptr
, &_width
, &_height );
}
int new_w = 0;
int new_h = 0;
Utility::calculateImageSize( _width
, _height
, src_w
, src_h
, new_w
, new_h );
evas_object_resize( _image
, new_w
, new_h );
}
evas_object_image_pixels_dirty_set( _image
, 1 );
return result;
}
int main(int argc, char *argv[])
{
Ecore_Evas *ee;
Evas_Object *bridge, *img;
const char *opt, *input, *output, *params;
int r = 0, w = -1, h = -1, err;
double scale = -1.0;
if (argc < 4) {
fprintf(stderr,
"Usage:\n"
"\t%s <percentage%%|WxH|w=W|h=H> <input> <output>"
" [save-params]\n"
"where save-params is evas supported parameters, like:\n"
"\tquality=85\n"
"\tcompress=9\n",
argv[0]);
return 1;
}
opt = argv[1];
input = argv[2];
output = argv[3];
params = argv[4];
if (strncasecmp(opt, "w=", 2) == 0) {
char *end = NULL;
w = strtol(opt + 2, &end, 10);
if (!end || *end != '\0') {
fprintf(stderr, "ERROR: invalid decimal integer '%s'\n",
opt + 2);
return 1;
} else if (w < 1) {
fprintf(stderr, "ERROR: invalid width %d, must be >= 1\n", w);
return 1;
}
} else if (strncasecmp(opt, "h=", 2) == 0) {
char *end = NULL;
h = strtol(opt + 2, &end, 10);
if (!end || *end != '\0') {
fprintf(stderr, "ERROR: invalid decimal integer '%s'\n",
opt + 2);
return 1;
} else if (h < 1) {
fprintf(stderr, "ERROR: invalid height %d, must be >= 1\n", h);
return 1;
}
} else if (strchr(opt, '%')) {
char *end = NULL;
scale = strtod(opt, &end);
if (!end || *end != '%') {
fprintf(stderr, "ERROR: invalid percentual '%s'\n", opt);
return 1;
} else if (scale <= 0.0) {
fprintf(stderr, "ERROR: invalid percentual %g, must be > 0.0\n",
scale);
return 1;
}
scale /= 100.0;
} else if (strchr(opt, 'x')) {
if (sscanf(opt, "%dx%d", &w, &h) != 2) {
fprintf(stderr, "ERROR: invalid size format '%s'\n", opt);
return 1;
} else if (w < 1) {
fprintf(stderr, "ERROR: invalid width %d, must be >= 1\n", w);
return 1;
} else {
fprintf(stderr, "ERROR: invalid height %d, must be >= 1\n", h);
return 1;
}
} else {
fprintf(stderr,
"ERROR: first parameter must be in format:\n"
"\tpercentage%% - example: 10%%\n"
"\tWxH - example: 1024x768\n"
"\tw=W - example: w=1024\n"
"\th=H - example: h=768\n"
"But '%s' was used!\n",
opt);
return 1;
}
ecore_evas_init();
evas_init();
ee = ecore_evas_buffer_new(1, 1);
bridge = ecore_evas_object_image_new(ee);
img = evas_object_image_add(ecore_evas_object_evas_get(bridge));
evas_object_image_smooth_scale_set(img, EINA_TRUE);
if (w > 0 && h > 0)
evas_object_image_load_size_set(img, w, h);
evas_object_image_file_set(img, input, NULL);
err = evas_object_image_load_error_get(img);
if (err != EVAS_LOAD_ERROR_NONE) {
const char *msg = evas_load_error_str(err);
fprintf(stderr, "ERROR: could not load '%s': %s\n", input, msg);
r = 1;
goto end;
}
if (w < 1 || h < 1) {
int iw, ih;
evas_object_image_size_get(img, &iw, &ih);
if (iw < 0 || ih < 0) {
fprintf(stderr, "ERROR: invalid source image size %dx%d (%s)\n",
iw, ih, input);
goto end;
}
if (scale > 0) {
w = ceil(iw * scale);
h = ceil(ih * scale);
} else if (w < 1)
w = ceil(iw * (double)h / (double)ih);
else if (h < 1)
h = ceil(ih * (double)w / (double)iw);
if (iw != w && ih != h)
evas_object_image_load_size_set(img, w, h);
}
printf("output: %s, size: %dx%d, alpha: %s, params: %s\n",
output, w, h,
evas_object_image_alpha_get(img) ? "yes" : "no",
params ? params : "<none>");
evas_object_image_fill_set(img, 0, 0, w, h);
evas_object_resize(img, w, h);
evas_object_show(img);
evas_object_image_alpha_set(bridge, evas_object_image_alpha_get(img));
evas_object_image_size_set(bridge, w, h);
ecore_evas_manual_render(ecore_evas_object_ecore_evas_get(bridge));
evas_object_image_save(bridge, output, NULL, params);
end:
evas_object_del(img);
evas_object_del(bridge);
ecore_evas_free(ee);
evas_shutdown();
ecore_evas_shutdown();
return r;
}
