static int EvasImageSetData( vout_display_t *vd ) { vout_display_sys_t *sys = vd->sys; struct buffer *p_buffer = sys->p_new_buffer; if( sys->u.evas.b_yuv ) { void *p_data = evas_object_image_data_get( sys->p_evas, 1 ); const uint8_t **pp_rows = (const uint8_t **) p_data; if( !p_data ) return -1; for( unsigned int i = 0; i < sys->i_nb_planes; ++i ) { plane_t *p_plane = &sys->p_planes[sys->i_planes_order[i]]; for( int j = 0; j < p_plane->i_visible_lines; ++j ) *(pp_rows++) = &p_buffer->p[i][j * p_plane->i_pitch]; } evas_object_image_data_set( sys->p_evas, p_data ); } else evas_object_image_data_set( sys->p_evas, p_buffer->p[0] ); return 0; }
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; }
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; }
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); }
/** * @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); }
void ewk_paint_context_free(Ewk_Paint_Context* context) { EINA_SAFETY_ON_NULL_RETURN(context); if (context->image && context->pixels) { // Decrease refcount inside image object. evas_object_image_data_set(context->image, context->pixels); } delete context; }
static void _ecore_evas_resize(Ecore_Evas *ee, int w, int h) { Evas_Engine_Info_Buffer *einfo; Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data; int stride = 0; if (w < 1) w = 1; if (h < 1) h = 1; ee->req.w = w; ee->req.h = h; if ((w == ee->w) && (h == ee->h)) return; ee->w = w; ee->h = h; evas_output_size_set(ee->evas, ee->w, ee->h); evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h); evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h); if (bdata->image) { bdata->pixels = evas_object_image_data_get(bdata->image, 1); stride = evas_object_image_stride_get(bdata->image); } else { if (bdata->pixels) bdata->free_func(bdata->data, bdata->pixels); bdata->pixels = bdata->alloc_func(bdata->data, ee->w * ee->h * sizeof(int)); stride = ee->w * sizeof(int); } einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas); if (einfo) { if (ee->alpha) einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32; else einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_RGB32; einfo->info.dest_buffer = bdata->pixels; einfo->info.dest_buffer_row_bytes = stride; einfo->info.use_color_key = 0; einfo->info.alpha_threshold = 0; einfo->info.func.new_update_region = NULL; einfo->info.func.free_update_region = NULL; if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo)) { ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver); } } if (bdata->image) evas_object_image_data_set(bdata->image, bdata->pixels); else bdata->resized = 1; }
/* 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; } }
EAPI Eina_Bool efx_bumpmap(Evas_Object *obj, Evas_Coord x, Evas_Coord y) { EFX *e; Efx_Bumpmap_Data *ebd; EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE); e = evas_object_data_get(obj, "efx-data"); if (!e) e = efx_new(obj); EINA_SAFETY_ON_NULL_RETURN_VAL(e, EINA_FALSE); if (!e->bumpmap_data) e->bumpmap_data = calloc(1, sizeof(Efx_Bumpmap_Data)); EINA_SAFETY_ON_NULL_RETURN_VAL(e->bumpmap_data, EINA_FALSE); ebd = e->bumpmap_data; ebd->e = e; ebd->x = x; ebd->y = y; ebd->z = 30; ebd->depth = 0x200; ebd->red = 0x200; ebd->green = 0x200; ebd->blue = 0x200; ebd->ambient = 0; if (!ebd->img_data) { unsigned int *m; int w; int h; evas_object_image_size_get(obj, &w, &h); m = (unsigned int *)evas_object_image_data_get(obj, 1); ebd->img_data = (unsigned int *)malloc(w * h * sizeof(unsigned int)); if (!ebd->img_data) { free(ebd); return EINA_FALSE; } printf("memcpy\n"); memcpy(ebd->img_data, m, (w * h * sizeof(unsigned int))); evas_object_image_data_set(obj, m); } _bumpmap(ebd); return EINA_TRUE; (void)efx_speed_str; }
static Eina_Bool _ewk_view_single_smart_scrolls_process(Ewk_View_Smart_Data* smartData) { Evas_Coord imageWidth, imageHeight; void* pixels = evas_object_image_data_get(smartData->backing_store, 1); evas_object_image_size_get(smartData->backing_store, &imageWidth, &imageHeight); const WTF::Vector<WebCore::IntSize>& scrollOffset = ewk_view_scroll_offsets_get(smartData->_priv); const WTF::Vector<WebCore::IntRect>& rectsToScroll = ewk_view_scroll_rects_get(smartData->_priv); for (size_t i = 0; i < scrollOffset.size(); ++i) _ewk_view_single_scroll_process_single(smartData, pixels, imageWidth, imageHeight, scrollOffset[i], rectsToScroll[i]); evas_object_image_data_set(smartData->backing_store, pixels); return true; }
void _eyelight_viewer_slideshow_slides_destroy(Eyelight_Viewer* pres) { int i; int size = pres->slideshow_nb_slides; for(i=0;i<size;i++) { if(pres->slideshow_image_thumbnails[i]) { evas_object_image_data_set(pres->slideshow_image_thumbnails[i],NULL); evas_object_del(pres->slideshow_image_thumbnails[i]); } } evas_object_del(pres->slideshow_background); EYELIGHT_FREE(pres->slideshow_image_thumbnails); }
static bool _ewk_view_tiled_render_cb(void* data, Ewk_Tile* tile, const Eina_Rectangle* area) { Ewk_View_Private_Data* priv = static_cast<Ewk_View_Private_Data*>(data); Eina_Rectangle rect = {area->x + tile->x, area->y + tile->y, area->w, area->h}; uint8_t* pixels = static_cast<uint8_t*>(evas_object_image_data_get(tile->image, true)); Ewk_Paint_Context* context = ewk_paint_context_from_image_data_new(pixels, tile->width, tile->height, tile->cspace); ewk_paint_context_translate(context, -tile->x, -tile->y); bool result = ewk_view_paint_contents(priv, context, &rect); ewk_paint_context_free(context); evas_object_image_data_set(tile->image, pixels); return result; }
static Eina_Bool _ewk_view_single_smart_scrolls_process(Ewk_View_Smart_Data* smartData) { const Ewk_Scroll_Request* sr; const Ewk_Scroll_Request* sr_end; Evas_Coord ow, oh; size_t count; void* pixels = evas_object_image_data_get(smartData->backing_store, 1); evas_object_image_size_get(smartData->backing_store, &ow, &oh); sr = ewk_view_scroll_requests_get(smartData->_priv, &count); sr_end = sr + count; for (; sr < sr_end; sr++) _ewk_view_single_scroll_process_single(smartData, pixels, ow, oh, sr); evas_object_image_data_set(smartData->backing_store, pixels); return true; }
static int EvasDeinitMainloopCb( vout_display_t *vd ) { vout_display_sys_t *sys = vd->sys; 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 ); evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MOUSE_DOWN, EventMouseDownCb, vd ); evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MOUSE_UP, EvasMouseUpCb, vd ); evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MOUSE_MOVE, EvasMouseMoveCb, vd ); evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MULTI_DOWN, EvasMultiDownCb, vd ); evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MULTI_UP, EvasMultiUpCb, vd ); evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_MULTI_MOVE, EvasMultiMoveCb, vd ); #ifdef HAVE_EVAS_CALLBACK_KEY_UP evas_object_event_callback_del_full( sys->p_evas, EVAS_CALLBACK_KEY_UP, EvasKeyUpCb, vd ); #endif if( !sys->b_evas_changed ) { evas_object_image_data_set( sys->p_evas, NULL ); evas_object_image_pixels_dirty_set( sys->p_evas, 0 ); } return 0; }
static void _emotion_image_data_zero(Evas_Object *img) { void *data = NULL; data = evas_object_image_data_get(img, 1); if (data) { int w, h, sz = 0; Evas_Colorspace cs; evas_object_image_size_get(img, &w, &h); cs = evas_object_image_colorspace_get(img); if (cs == EVAS_COLORSPACE_ARGB8888) sz = w * h * 4; if ((cs == EVAS_COLORSPACE_YCBCR422P601_PL) || (cs == EVAS_COLORSPACE_YCBCR422P709_PL)) sz = h * 2 * sizeof(unsigned char *); if (sz != 0) memset(data, 0, sz); } evas_object_image_data_set(img, data); }
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 EvasImageSetup( vout_display_t *vd ) { vout_display_sys_t *sys = vd->sys; char *psz_fcc = var_InheritString( vd, "evas-image-chroma" ); if( psz_fcc ) { vd->fmt.i_chroma = vlc_fourcc_GetCodecFromString( VIDEO_ES, psz_fcc ); free( psz_fcc ); } switch( vd->fmt.i_chroma ) { case VLC_CODEC_RGB32: sys->u.evas.i_colorspace = EVAS_COLORSPACE_ARGB8888; break; /* Not implemented yet */ #if 0 case VLC_CODEC_RGB16: sys->u.evas.i_colorspace = EVAS_COLORSPACE_RGB565_A5P; break; #endif case VLC_CODEC_YUYV: sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR422601_PL; sys->u.evas.b_yuv = true; break; /* FIXME: SIGSEGV in evas_gl_common_texture_nv12_update */ #if 0 case VLC_CODEC_NV12: sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR420NV12601_PL; sys->u.evas.b_yuv = true; break; #endif case VLC_CODEC_YV12: sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR422P601_PL; sys->u.evas.b_yuv = true; break; default: case VLC_CODEC_I420: sys->u.evas.i_colorspace = EVAS_COLORSPACE_YCBCR422P601_PL; vd->fmt.i_chroma = VLC_CODEC_I420; sys->u.evas.b_yuv = true; break; } evas_object_image_colorspace_set( sys->p_evas, sys->u.evas.i_colorspace ); evas_object_image_data_set( sys->p_evas, NULL ); /* No rotation support with EvasImage */ sys->b_apply_rotation = true; FmtUpdate( vd ); /* No aspect ratio support with EvasImage */ vd->info.has_pictures_invalid = true; sys->pf_set_data = EvasImageSetData; sys->pf_buffers_alloc = EvasImageBuffersAlloc; sys->pf_buffers_free = EvasImageBuffersFree; msg_Dbg( vd, "using evas_image" ); return 0; }
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); }
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; }
static float calculateDifference(Evas_Object* baselineImage, Evas_Object* actualImage, RefPtr<Evas_Object>& differenceImage) { int width, height, baselineWidth, baselineHeight; evas_object_image_size_get(actualImage, &width, &height); evas_object_image_size_get(baselineImage, &baselineWidth, &baselineHeight); if (width != baselineWidth || height != baselineHeight) { printf("Error, test and reference image have different sizes.\n"); return 100; // Completely different. } OwnArrayPtr<unsigned char> diffBuffer = adoptArrayPtr(new unsigned char[width * height]); if (!diffBuffer) abortWithErrorMessage("could not create difference buffer"); const int actualRowStride = evas_object_image_stride_get(actualImage); const int baseRowStride = evas_object_image_stride_get(baselineImage); unsigned numberOfDifferentPixels = 0; float totalDistance = 0; float maxDistance = 0; unsigned char* actualPixels = static_cast<unsigned char*>(evas_object_image_data_get(actualImage, EINA_FALSE)); unsigned char* basePixels = static_cast<unsigned char*>(evas_object_image_data_get(baselineImage, EINA_FALSE)); unsigned char* currentDiffPixel = diffBuffer.get(); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { unsigned char* actualPixel = pixelFromImageData(actualPixels, actualRowStride, x, y); unsigned char* basePixel = pixelFromImageData(basePixels, baseRowStride, x, y); const float distance = calculatePixelDifference(basePixel, actualPixel); *currentDiffPixel++ = static_cast<unsigned char>(distance * 255.0f); if (distance >= 1.0f / 255.0f) { ++numberOfDifferentPixels; totalDistance += distance; maxDistance = std::max<float>(maxDistance, distance); } } } // When using evas_object_image_data_get(), a complementary evas_object_data_set() must be // issued to balance the reference count, even if the image hasn't been changed. evas_object_image_data_set(baselineImage, basePixels); evas_object_image_data_set(actualImage, actualPixels); // Compute the difference as a percentage combining both the number of // different pixels and their difference amount i.e. the average distance // over the entire image float difference = 0; if (numberOfDifferentPixels) difference = 100.0f * totalDistance / (height * width); if (difference <= gTolerance) difference = 0; else { difference = roundf(difference * 100.0f) / 100.0f; difference = std::max(difference, 0.01f); // round to 2 decimal places differenceImage = adoptRef(differenceImageFromDifferenceBuffer(evas_object_evas_get(baselineImage), diffBuffer.get(), width, height)); } return difference; }
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; }
static void _bumpmap(Efx_Bumpmap_Data *ebd) { Evas_Object *o; int w; int h; int i, j; int x; int y; int z; int depth; int red; int green; int blue; int ambient; double z_2, lightx, lighty; int mx; int my; unsigned int *d1; unsigned int *d2; unsigned int *src; unsigned int *mp; unsigned int *mpy; unsigned int *mpp; x = ebd->x; y = ebd->y; z = ebd->z; red = ebd->red / 0x100; green = ebd->green / 0x100; blue = ebd->blue / 0x100; ambient = ebd->ambient / 0x100; depth = ebd->depth / 0x100; depth /= (255 * (255 + 255 + 255)); z_2 = z * z; o = ebd->e->obj; evas_object_image_size_get(o, &w, &h); if ((!w) || (!h)) return; d1 = malloc(w * h * sizeof(int)); memcpy(d1, ebd->img_data, w * h * sizeof(int)); src = d1; d2 = malloc(w * h * sizeof(int)); memcpy(d2, ebd->img_data, w * h * sizeof(int)); mpp = d2; my = h; lighty = -y; for (j = h; --j >= 0;) { mp = mpp; mpp += w; if (--my <= 0) { mpp -= w * h; my = h; } mpy = mpp; mx = w; lightx = -x; i = w - 1; do { double x1, y_1, v; int r, g, b, gr; gr = A_VAL(mp) * (R_VAL(mp) + G_VAL(mp) + B_VAL(mp)); y_1 = depth * (double)(A_VAL(mpy) * (R_VAL(mpy) + G_VAL(mpy) + B_VAL(mpy)) - gr); mp++; mpy++; if (--mx <= 0) { mp -= w; mpy -= w; mx = w; } x1 = depth * (double)(A_VAL(mp) * (R_VAL(mp) + G_VAL(mp) + B_VAL(mp)) - gr); v = x1 * lightx + y_1 * lighty + z; v /= sqrt((x1 * x1) + (y_1 * y_1) + 1.0); v /= sqrt((lightx * lightx) + (lighty * lighty) + z_2); v += ambient; r = v * R_VAL(src) * red; g = v * G_VAL(src) * green; b = v * B_VAL(src) * blue; if (r < 0) r = 0; else if (r > 255) r = 255; if (g < 0) g = 0; else if (g > 255) g = 255; if (b < 0) b = 0; else if (b > 255) b = 255; R_VAL(src) = r; G_VAL(src) = g; B_VAL(src) = b; lightx++; src++; } while (--i >= 0); lighty++; } unsigned int *m; m = (unsigned int *)evas_object_image_data_get(o, 1); memcpy(m, d1, w * h * sizeof(unsigned int)); evas_object_image_data_set(o, m); evas_object_image_data_update_add(o, 0, 0, w, h); free(d1); free(d2); }
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); }