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);
}
EAPI void
e_icon_size_get(Evas_Object *obj, int *w, int *h)
{
E_Smart_Data *sd;
sd = evas_object_smart_data_get(obj);
if (!sd) return;
return evas_object_image_size_get(sd->obj, w, h);
}
EAPI void *
e_icon_data_get(const Evas_Object *obj, int *w, int *h)
{
E_Smart_Data *sd;
if (evas_object_smart_smart_get(obj) != _e_smart) SMARTERR(NULL);
if (!(sd = evas_object_smart_data_get(obj))) return NULL;
if (sd->edje) return NULL;
evas_object_image_size_get(sd->obj, w, h);
return evas_object_image_data_get(sd->obj, 0);
}
EAPI void *
e_icon_data_get(Evas_Object *obj, int *w, int *h)
{
E_Smart_Data *sd;
sd = evas_object_smart_data_get(obj);
if (!sd) return NULL;
if (!strcmp(evas_object_type_get(sd->obj), "edje"))
return NULL;
evas_object_image_size_get(sd->obj, w, h);
return evas_object_image_data_get(sd->obj, 0);
}
unsigned int read_texture(Evas_Object *parent, const char *filename) {
unsigned int gltex_object;
int w, h;
int surface_w, surface_h;
evas_object_geometry_get(parent, NULL, NULL, &surface_w, &surface_h);
Evas_Object* inline_buffer = elm_win_add(parent,"Img Read",ELM_WIN_INLINED_IMAGE);
evas_object_move(inline_buffer, 0, 0);
evas_object_resize(inline_buffer, surface_w, surface_h);
evas_object_show(inline_buffer);
Evas* canvas = evas_object_evas_get(inline_buffer);
Evas_Object* image = evas_object_image_add(canvas);
char path[200];
sprintf(path, "%s%s", app_get_resource_path(), filename);
evas_object_image_file_set(image, path, NULL);
evas_object_image_size_get(image, &w, &h);
evas_object_image_fill_set(image, 0, 0, w, h);
evas_object_image_filled_set(image, EINA_TRUE);
evas_object_resize(image, w, h);
evas_object_show(image);
elm_win_render(inline_buffer);
GLubyte* pixels;
pixels = (GLubyte*) evas_object_image_data_get(image, EINA_FALSE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &gltex_object);
glBindTexture(GL_TEXTURE_2D, gltex_object);
glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, w, h, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
glGenerateMipmap(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
evas_object_del(inline_buffer);
return gltex_object;
}
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;
}
/* local subsystem globals */
static void
_e_icon_smart_reconfigure(E_Smart_Data *sd)
{
int iw, ih;
Evas_Coord x, y, w, h;
if (!strcmp(evas_object_type_get(sd->obj), "edje"))
{
w = sd->w;
h = sd->h;
x = sd->x;
y = sd->y;
evas_object_move(sd->obj, x, y);
evas_object_resize(sd->obj, w, h);
}
else
{
ih = 0;
ih = 0;
evas_object_image_size_get(sd->obj, &iw, &ih);
if (iw < 1) iw = 1;
if (ih < 1) ih = 1;
if (sd->fill_inside)
{
w = sd->w;
h = ((double)ih * w) / (double)iw;
if (h > sd->h)
{
h = sd->h;
w = ((double)iw * h) / (double)ih;
}
}
else
{
w = sd->w;
h = ((double)ih * w) / (double)iw;
if (h < sd->h)
{
h = sd->h;
w = ((double)iw * h) / (double)ih;
}
}
x = sd->x + ((sd->w - w) / 2);
y = sd->y + ((sd->h - h) / 2);
evas_object_move(sd->obj, x, y);
evas_object_image_fill_set(sd->obj, 0, 0, w, h);
evas_object_resize(sd->obj, w, h);
}
}
static void resizeEcoreEvasIfNeeded(Evas_Object* image)
{
int newWidth, newHeight;
evas_object_image_size_get(image, &newWidth, &newHeight);
int currentWidth, currentHeight;
ecore_evas_screen_geometry_get(gEcoreEvas.get(), 0, 0, ¤tWidth, ¤tHeight);
if (newWidth > currentWidth)
currentWidth = newWidth;
if (newHeight > currentHeight)
currentHeight = newHeight;
ecore_evas_resize(gEcoreEvas.get(), currentWidth, currentHeight);
}
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;
}
Ewk_Paint_Context* ewk_paint_context_from_image_new(Evas_Object* image)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(image, 0);
Evas_Coord width, height;
uint8_t* pixels = static_cast<uint8_t*>(evas_object_image_data_get(image, true));
evas_object_image_size_get(image, &width, &height);
Ewk_Paint_Context* context = ewk_paint_context_from_image_data_new(pixels, width, height, EVAS_COLORSPACE_ARGB8888);
if (context) {
context->pixels = pixels;
context->image = image;
}
return context;
}
static Eina_Bool _ewk_view_single_smart_scrolls_process(Ewk_View_Smart_Data *sd)
{
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(sd->backing_store, 1);
evas_object_image_size_get(sd->backing_store, &ow, &oh);
sr = ewk_view_scroll_requests_get(sd->_priv, &count);
sr_end = sr + count;
for (; sr < sr_end; sr++)
_ewk_view_single_scroll_process_single(sd, pixels, ow, oh, sr);
return EINA_TRUE;
}
static void _main_view_mousedown_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
int result;
main_view *main_view_data = data;
int w, h;
camera_state_e cur_state = CAMERA_STATE_NONE;
Evas_Event_Mouse_Down *ev = event_info;
INF("mousedown x: %d y: %d", ev->canvas.x, ev->canvas.y);
evas_object_image_size_get(main_view_data->preview_canvas, &w, &h);
INF("image size w: %d h: %d", w, h);
if (main_view_data->camera_enabled)
{
result = camera_get_state(main_view_data->camera, &cur_state);
if(CAMERA_ERROR_NONE == result)
{
if(cur_state == CAMERA_STATE_PREVIEW)
{
result = camera_start_capture(main_view_data->camera, _main_view_camera_capturing_cb, _main_view_camera_capture_completed_cb, data);
if(result == CAMERA_ERROR_NONE)
{
INF("start camera capture successful");
//INF("Can not start camera capture");
}
}
else if(cur_state == CAMERA_STATE_CAPTURED)
{
INF("can not start capture current state CAMERA_STATE_CAPTURED");
}
else if(cur_state == CAMERA_STATE_CAPTURING)
{
INF("can not start capture current state CAMERA_STATE_CAPTURING");
}
}
else
{
ERR("Error getting camera state after click");
}
}
else
{
ERR("Camera hasn't been initialized.");
}
}
EAPI void
e_icon_size_get(const Evas_Object *obj, 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)))
{
if (w) *w = 0;
if (h) *h = 0;
return;
}
if (sd->edje)
edje_object_size_min_calc(sd->obj, w, h);
else
evas_object_image_size_get(sd->obj, w, h);
}
int get_top_margin()
{
int imgw,imgh;
int hor,ver;
int firstpix;
int *imgptr=evas_object_image_data_get(EWL_PDF(pdfwidget)->image,0);
evas_object_image_size_get(EWL_PDF(pdfwidget)->image,&imgw,&imgh);
firstpix=imgptr[0];
for(ver=0;ver<imgh;ver++)
{
for(hor=0;hor<imgw;hor++)
{
if(imgptr[ver*imgw+hor]!=firstpix)
return ver;
}
}
return 0;
}
void
icon_editor_file_save()
{
if (!editor || !editor->edf) return;
icon_editor_exec_set(ewl_entry_text_get(EWL_ENTRY(editor->exec.entry)));
if (editor->icon_image)
{
int w, h;
Evas_Object *im;
im = EWL_IMAGE(editor->icon_image)->image;
evas_object_image_size_get(im, &w, &h);
icon_editor_image_data_set(evas_object_image_data_get(im, FALSE), w, h);
}
/* FIXME create a new file name based on the name */
/* (delete the old file first?) */
edje_edit_file_save(editor->edf, editor->file);
}
PassRefPtr<cairo_surface_t> createSurfaceForImage(Evas_Object* image)
{
ASSERT(image);
Evas_Coord width;
Evas_Coord height;
evas_object_image_size_get(image, &width, &height);
ASSERT(width > 0 && height > 0);
unsigned char* buffer = static_cast<unsigned char*>(const_cast<void*>(evas_object_image_data_get(image, true)));
RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create_for_data(buffer, CAIRO_FORMAT_ARGB32, width, height, width * 4));
cairo_status_t status = cairo_surface_status(surface.get());
if (status != CAIRO_STATUS_SUCCESS) {
EINA_LOG_ERR("Could not create cairo surface: %s", cairo_status_to_string(status));
return 0;
}
return surface.release();
}
void
_evas_object_bg_set (Evas_Object *o, int r, int g, int b)
{
unsigned int *m;
int w, h;
int i, j;
evas_object_image_size_get (o, &w, &h);
evas_object_image_fill_set (o, 0, 0, w, h);
m = (unsigned int *)evas_object_image_data_get (o, 1);
if (!m)
return;
for (j = 0; j < h; j++) {
for (i = 0; i < w; i++) {
m[j * w + i] = (255 << 24) | (r << 16) | (g << 8) | b;
}
}
evas_object_image_data_update_add (o, 0, 0, w, h);
evas_object_resize (o, w, h);
}
int get_right_margin()
{
int imgw,imgh;
int hor,ver;
int firstpix;
int *imgptr=evas_object_image_data_get(EWL_PDF(pdfwidget)->image,0);
evas_object_image_size_get(EWL_PDF(pdfwidget)->image,&imgw,&imgh);
firstpix=imgptr[imgw-1];
for(hor=imgw-1;hor>=0;hor--)
{
//fprintf(stderr,"firstpix:%d",firstpix);
for(ver=0;ver<imgh;ver++)
{
//fprintf(stderr,"pix:%d",imgptr[ver*imgw+hor]);
if(imgptr[ver*imgw+hor]!=firstpix)
return imgw-1-hor;
}
}
return 0;
}
int get_bottom_margin()
{
int imgw,imgh;
int hor,ver;
int firstpix;
int curpix;
int *imgptr=evas_object_image_data_get(EWL_PDF(pdfwidget)->image,0);
evas_object_image_size_get(EWL_PDF(pdfwidget)->image,&imgw,&imgh);
firstpix=imgptr[(imgh-1)*imgw];
for(ver=imgh-1;ver>=0;ver--)
{
for(hor=0;hor<imgw;hor++)
{
if(imgptr[ver*imgw+hor]!=firstpix)
return imgh-1-ver;
}
}
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 void _walle_wall_populate(Walle *walle, const char *directory, const char *theme)
{
Evas_Object *o;
Evas_Coord ow, oh, w, h;
Eina_List *files = NULL;
char *file = NULL;
char filename[4096];
if (!ecore_file_is_dir(directory) && ecore_file_dir_is_empty(directory))
return;
files = ecore_file_ls(directory);
if (!files)
return;
EINA_LIST_FREE(files, file)
{
sprintf(filename, "%s/%s", directory, file);
o = evas_object_image_add(walle->evas);
evas_object_image_file_set(o, filename, NULL);
switch(evas_object_image_load_error_get(o))
{
case EVAS_LOAD_ERROR_NONE:
{
evas_object_event_callback_add(o, EVAS_CALLBACK_RESIZE, _walle_picture_cb_resize, o);
evas_object_image_size_get(o, &w, &h);
oh = 200;
ow = oh * (float)w/(float)h;
evas_object_image_load_size_set(o, ow, oh);
evas_object_image_fill_set(o, 0, 0, ow, oh);
evas_object_resize(o, ow, oh);
evas_object_size_hint_min_set(o, ow, oh);
walle_wall_append(walle->o_wall, o);
walle->pictures = eina_list_append(walle->pictures, o);
}
break;
default:
evas_object_del(o);
break;
}
}
static Eina_Bool
_ecore_evas_buffer_prepare(Ecore_Evas *ee)
{
Ecore_Evas_Engine_Buffer_Data *bdata;
bdata = ee->engine.data;
if (bdata->image)
{
int w, h;
evas_object_image_size_get(bdata->image, &w, &h);
if ((w != ee->w) || (h != ee->h))
_ecore_evas_resize(ee, w, h);
bdata->pixels = evas_object_image_data_get(bdata->image, 1);
}
else if (bdata->resized)
{
if (ee->func.fn_resize) ee->func.fn_resize(ee);
bdata->resized = 0;
}
return EINA_TRUE;
}
Evas_Object *
engage_element_new(Evas * e, const char *bfile, const char *bgroup,
const char *ifile, const char *igroup)
{
char buf[PATH_MAX];
int w = 48, h = 48;
Evas_Object *result = NULL;
Engage_Element *data = NULL;
if ((result = engage_element_object_new(e))) {
if ((data = evas_object_smart_data_get(result))) {
data->clip = evas_object_rectangle_add(e);
evas_object_color_set(data->clip, 255, 255, 255, 255);
evas_object_layer_set(data->clip, 0);
evas_object_show(data->clip);
if ((data->behavior = engage_element_behavior_new(e, bfile, bgroup))) {
evas_object_clip_set(data->behavior, data->clip);
if ((data->icon = engage_element_icon_new(e, ifile, igroup))) {
if (!strcmp(evas_object_type_get(data->icon), "image")) {
evas_object_image_size_get(data->icon, &data->iw, &data->ih);
evas_object_image_fill_set(data->icon, 0.0, 0.0,
(Evas_Coord) data->iw,
(Evas_Coord) data->ih);
}
evas_object_clip_set(data->icon, data->clip);
} else {
evas_object_del(result);
result = NULL;
}
}
}
}
return (result);
}
void FileLoader::ReadTexture(const char *filename, TexData &out) const
{
Evas_Object * parent = SampleLauncher::GetInstance()->GetParent();
int w, h;
int surface_w, surface_h;
evas_object_geometry_get(parent, NULL, NULL, &surface_w, &surface_h);
Evas_Object * inline_buffer = elm_win_add(parent, "Img Read", ELM_WIN_INLINED_IMAGE);
evas_object_move(inline_buffer, 0, 0);
evas_object_resize(inline_buffer, surface_w, surface_h);
evas_object_show(inline_buffer);
Evas *canvas = evas_object_evas_get(inline_buffer);
Evas_Object * image = evas_object_image_add(canvas);
char path[200];
sprintf(path, "%s%s", app_get_resource_path(), filename);
evas_object_image_file_set(image, path, NULL);
evas_object_image_size_get(image, &w, &h);
evas_object_image_fill_set(image, 0, 0, w, h);
evas_object_image_filled_set(image, EINA_TRUE);
evas_object_resize(image, w, h);
evas_object_show(image);
elm_win_render(inline_buffer);
GLubyte *pixels;
pixels = static_cast<GLubyte *>(evas_object_image_data_get(image, EINA_FALSE));
out.SetData(w * h, pixels, w, h, GL_BGRA_EXT);
evas_object_del(inline_buffer);
}
void setup_panel(Evas *_e)
{
int w;
Panel_Button *pbutton1, *pbutton2, *pbutton3;
o_panel = evas_object_image_add(_e);
evas_object_image_file_set(o_panel, IM "panel.png",
IM "panel.png");
evas_object_image_size_get(o_panel, &w, NULL);
evas_object_move(o_panel, 0, 0);
evas_object_resize(o_panel, w, win_h);
evas_object_image_fill_set(o_panel, 0, 0, w, win_h);
evas_object_layer_set(o_panel, 200);
evas_object_show(o_panel);
/* Panel title */
o_txt_paneltitle = evas_object_text_add(_e);
evas_object_text_font_set(o_txt_paneltitle, "sinon", 17);
evas_object_text_text_set(o_txt_paneltitle, "Etox Test");
evas_object_color_set(o_txt_paneltitle, 255, 255, 255, 255);
evas_object_layer_set(o_txt_paneltitle, 250);
evas_object_show(o_txt_paneltitle);
/* Panel buttons */
pbutton1 = panel_button(evas, "Basic", basic_tests());
pbuttons = eina_list_append(pbuttons, pbutton1);
pbutton2 = panel_button(evas, "Style", style_tests());
pbuttons = eina_list_append(pbuttons, pbutton2);
pbutton3 = panel_button(evas, "Callbacks", callback_tests());
pbuttons = eina_list_append(pbuttons, pbutton3);
}
static Eina_Bool _ewk_view_single_smart_repaints_process(Ewk_View_Smart_Data* smartData)
{
if (smartData->animated_zoom.zoom.current < 0.00001) {
Evas_Object* clip = evas_object_clip_get(smartData->backing_store);
// reset effects of zoom_weak_set()
evas_object_image_fill_set(smartData->backing_store, 0, 0, smartData->view.w, smartData->view.h);
evas_object_move(clip, smartData->view.x, smartData->view.y);
Evas_Coord width = smartData->view.w;
Evas_Coord height = smartData->view.h;
Evas_Coord centerWidth, centerHeight;
ewk_frame_contents_size_get(smartData->main_frame, ¢erWidth, ¢erHeight);
if (width > centerWidth)
width = centerWidth;
if (height > centerHeight)
height = centerHeight;
evas_object_resize(clip, width, height);
}
Evas_Coord imageWidth, imageHeight;
evas_object_image_size_get(smartData->backing_store, &imageWidth, &imageHeight);
Eina_Tiler* tiler = eina_tiler_new(imageWidth, imageHeight);
if (!tiler) {
ERR("could not create tiler %dx%d", imageWidth, imageHeight);
return false;
}
ewk_view_layout_if_needed_recursive(smartData->_priv);
size_t count;
const Eina_Rectangle* paintRequest = ewk_view_repaints_pop(smartData->_priv, &count);
const Eina_Rectangle* paintRequestEnd = paintRequest + count;
for (; paintRequest < paintRequestEnd; paintRequest++)
eina_tiler_rect_add(tiler, paintRequest);
Eina_Iterator* iterator = eina_tiler_iterator_new(tiler);
if (!iterator) {
ERR("could not get iterator for tiler");
eina_tiler_free(tiler);
return false;
}
#if USE(TILED_BACKING_STORE)
WebCore::Frame* mainFrame = EWKPrivate::coreFrame(smartData->main_frame);
if (mainFrame && mainFrame->tiledBackingStore())
mainFrame->tiledBackingStore()->coverWithTilesIfNeeded();
#endif
Ewk_Paint_Context* context = ewk_paint_context_from_image_new(smartData->backing_store);
ewk_paint_context_save(context);
Eina_Rectangle* rect;
EINA_ITERATOR_FOREACH(iterator, rect) {
ewk_view_paint(smartData->_priv, context, rect);
evas_object_image_data_update_add(smartData->backing_store, rect->x, rect->y, rect->w, rect->h);
}
void
e_login_session_bar_init(E_Login_Session e)
{
int w, h;
Evas *evas;
Estyle *es = NULL;
double bgx, bgy, bgw, bgh;
int ix = 0, iy = 0;
int iw = 0, ih = 0;
Evas_List *l = NULL;
Evas_Object *o = NULL;
Session_Bar *sb = session_bar_new();
/* Session list background image */
evas = e->evas;
o = evas_object_image_add(evas);
evas_object_image_file_set(o, PACKAGE_DATA_DIR "/data/images/parch.png",
NULL);
iw = ih = 0;
evas_object_image_fill_set(o, 0.0, 0.0, (double) iw, (double) ih);
evas_object_resize(o, iw, ih);
evas_object_layer_set(o, 15);
evas_object_color_set(o, e->config->greeting.font.r,
e->config->greeting.font.g,
e->config->greeting.font.b, 100);
ix = ((((e->geom.w / e->config->screens.w) - w) * 0.5));
iy = 120;
evas_object_move(o, ix, iy);
sb->listbg = o;
/* Session list heading */
es = estyle_new(evas, "XSessions", "raised");
estyle_set_color(es, e->config->greeting.font.r,
e->config->greeting.font.g, e->config->greeting.font.b,
e->config->greeting.font.a);
estyle_set_font(es, e->config->greeting.font.name,
e->config->greeting.font.size);
estyle_callback_add(es, EVAS_CALLBACK_MOUSE_UP,
session_bar_toggle_visibility, sb);
estyle_set_layer(es, 25);
estyle_geometry(es, NULL, NULL, &w, &h);
ix = ((((e->geom.w / e->config->screens.w) - w) * 0.9));
iy = ((((e->geom.h / e->config->screens.h) - h) * 1.0));
estyle_move(es, ix, iy);
estyle_show(es);
sb->header = es;
/* Build session list */
iy = 125;
evas_object_geometry_get(sb->listbg, &bgx, &bgy, &bgw, &bgh);
for (l = e->config->sessions; l && iy <= 330; l = l->next)
{
char *session_name = ((E_Login_Session_Type *) evas_list_data(l))->name;
es = estyle_new(evas, session_name, "raised");
estyle_set_color(es, e->config->greeting.font.r,
e->config->greeting.font.g, e->config->greeting.font.b,
e->config->greeting.font.a);
estyle_set_font(es, e->config->greeting.font.name,
e->config->greeting.font.size);
estyle_set_layer(es, 25);
estyle_callback_add(es, EVAS_CALLBACK_MOUSE_UP,
session_bar_session_clicked_cb, e);
estyle_callback_add(es, EVAS_CALLBACK_MOUSE_IN,
session_bar_session_mouse_in_cb, e);
estyle_callback_add(es, EVAS_CALLBACK_MOUSE_OUT,
session_bar_session_mouse_out_cb, e);
sb->sessions = evas_list_append(sb->sessions, es);
estyle_geometry(es, NULL, NULL, &w, &h);
ix = ((((e->geom.w / e->config->screens.w) - w) * 0.5));
estyle_move(es, ix, iy);
iy += h + 5;
bgh += h + 5;
if (w > bgw)
{
bgw = w + 12;
ix = ((((e->geom.w / e->config->screens.w) - bgw) * 0.5));
evas_object_move(sb->listbg, ix, 120);
}
evas_object_image_fill_set(sb->listbg, 0.0, 0.0, (double) bgw,
(double) bgh);
evas_object_resize(sb->listbg, bgw, bgh);
}
/* Bullet */
o = evas_object_image_add(evas);
evas_object_image_file_set(o, PACKAGE_DATA_DIR "/data/images/bullet.png",
NULL);
evas_object_image_size_get(o, &iw, &ih);
evas_object_resize(o, iw, ih);
evas_object_image_fill_set(o, 0.0, 0.0, (double) iw, (double) ih);
evas_object_image_alpha_set(o, 1);
evas_object_color_set(o, e->config->greeting.font.r,
e->config->greeting.font.g,
e->config->greeting.font.b,
e->config->greeting.font.a);
evas_object_layer_set(o, 15);
evas_object_move(o, -99999, -99999);
sb->bullet = o;
/* Set default session to first in list (for now) */ ;
e->xsession = evas_list_data(e->config->sessions);
sb->win_geom.w = e->geom.w;
sb->win_geom.h = e->geom.h;
}
int
main (int argc, char *argv[])
{
Evas *evas = NULL;
Ecore_Evas *ee = NULL;
Ecore_X_Window win = 0;
Evas_Object *o = NULL;
Evas_Object *cont = NULL;
Evas_Object *image = NULL;
int iw, ih;
ecore_init ();
ecore_app_args_set (argc, (const char **) argv);
ecore_event_handler_add (ECORE_EVENT_SIGNAL_EXIT, exit_cb, NULL);
if (ecore_evas_init ())
{
ee = ecore_evas_software_x11_new (NULL, 0, 0, 0, 300, 120);
win = ecore_evas_software_x11_window_get(ee);
ecore_evas_title_set (ee, "Enlightenment Thumbnail Test");
ecore_evas_callback_delete_request_set (ee, window_del_cb);
ecore_evas_callback_resize_set (ee, window_resize_cb);
ecore_evas_callback_move_set (ee, window_move_cb);
evas = ecore_evas_get (ee);
o = esmart_trans_x11_new (evas);
esmart_trans_x11_type_set(o, Esmart_Trans_X11_Type_Background);
esmart_trans_x11_window_set(o, win);
evas_object_move (o, 0, 0);
evas_object_resize (o, 300, 120);
evas_object_layer_set (o, -5);
evas_object_name_set (o, "root_background");
evas_object_show (o);
o = evas_object_rectangle_add (evas);
evas_object_move (o, 0, 0);
evas_object_resize (o, 300, 120);
evas_object_layer_set (o, -6);
evas_object_color_set (o, 255, 255, 255, 0);
evas_object_name_set (o, "background");
evas_object_show (o);
o = esmart_draggies_new (ee);
evas_object_move (o, 0, 0);
evas_object_resize (o, 300, 120);
evas_object_layer_set (o, 255);
evas_object_color_set (o, 255, 255, 255, 0);
evas_object_name_set (o, "dragger");
esmart_draggies_button_set (o, 1);
evas_object_show (o);
if (argc < 2)
{
image = evas_object_image_add (evas);
evas_object_image_file_set (image, PACKAGE_DATA_DIR "/esmart.png",
NULL);
evas_object_image_size_get (image, &iw, &ih);
evas_object_resize (image, iw, ih);
evas_object_image_fill_set (image, 0.0, 0.0, (Evas_Coord) iw,
(Evas_Coord) ih);
evas_object_layer_set (image, 1000);
evas_object_pass_events_set (image, 1);
evas_object_show (image);
}
cont = esmart_container_new (evas);
evas_object_move (cont, 0, 0);
evas_object_resize (cont, 300, 120);
evas_object_layer_set (cont, 0);
evas_object_name_set (cont, "container");
evas_object_show (cont);
esmart_container_padding_set (cont, 10, 10, 10, 10);
esmart_container_spacing_set (cont, 5);
esmart_container_fill_policy_set (cont,
CONTAINER_FILL_POLICY_FILL_Y |
CONTAINER_FILL_POLICY_KEEP_ASPECT);
evas_object_event_callback_add (o, EVAS_CALLBACK_MOUSE_DOWN, bg_down_cb,
cont);
evas_object_event_callback_add (o, EVAS_CALLBACK_MOUSE_UP, bg_up_cb,
cont);
while (--argc)
{
if ((o = esmart_thumb_new (ecore_evas_get (ee), argv[argc])))
{
evas_object_layer_set (o, 2);
evas_object_show (o);
esmart_container_element_append (cont, o);
}
}
evas_object_resize (cont, 300, 120);
ecore_evas_show (ee);
if (ecore_x_composite_query())
{
ee = ecore_evas_software_x11_new (NULL, 0, 0, 0, 320, 120);
ecore_evas_title_set (ee, "Enlightenment Pixmap Test");
ecore_evas_callback_delete_request_set (ee, window_del_cb);
ecore_evas_callback_resize_set (ee, window_resize_cb);
ecore_evas_callback_move_set (ee, window_move_cb);
evas = ecore_evas_get (ee);
o = esmart_xpixmap_new (evas, 0, win);
evas_object_move (o, 0, 0);
evas_object_resize (o, 320, 120);
evas_object_layer_set (o, -5);
evas_object_name_set (o, "xpixmap");
evas_object_show (o);
o = evas_object_rectangle_add (evas);
evas_object_move (o, 0, 0);
evas_object_resize (o, 150, 30);
evas_object_layer_set (o, -3);
evas_object_color_set (o, 50, 50, 50, 50);
evas_object_name_set (o, "white_transparent_rect");
evas_object_show (o);
ecore_evas_show (ee);
}
ecore_main_loop_begin ();
}
return (0);
}
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;
}
