tizen 2.3 releasetizen_2.3_releasesubmit/tizen_2.3/20150202.053743tizen_2.3

6 files changed, 3550 insertions, 0 deletions

diff --git a/dynamicbox/src/dlist.c b/dynamicbox/src/dlist.c
new file mode 100644
index 0000000..cb3aa39
--- /dev/null
+++ b/dynamicbox/src/dlist.c
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2013  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "dlist.h"
+
+struct dlist {
+    struct dlist *next;
+    struct dlist *prev;
+    void *data;
+};
+
+struct dlist *dlist_append(struct dlist *list, void *data)
+{
+    struct dlist *item;
+
+    item = malloc(sizeof(*item));
+    if (!item) {
+	return NULL;
+    }
+
+    item->next = NULL;
+    item->data = data;
+
+    if (!list) {
+	item->prev = item;
+
+	list = item;
+    } else {
+	item->prev = list->prev;
+	item->prev->next = item;
+
+	list->prev = item;
+    }
+
+    assert(!list->prev->next && "item NEXT");
+
+    return list;
+}
+
+struct dlist *dlist_prepend(struct dlist *list, void *data)
+{
+    struct dlist *item;
+
+    item = malloc(sizeof(*item));
+    if (!item) {
+	return NULL;
+    }
+
+    if (!list) {
+	item->prev = item;
+	item->next = NULL;
+    } else {
+	item->prev = list->prev;
+	list->prev = item;
+	item->next = list;
+    }
+
+    return item;
+}
+
+struct dlist *dlist_remove(struct dlist *list, struct dlist *l)
+{
+    if (!list || !l) {
+	return NULL;
+    }
+
+    if (l == list) {
+	l->prev = list->prev;
+	list = l->next;
+    } else {
+	l->prev->next = l->next;
+    }
+
+    if (l->next) {
+	l->next->prev = l->prev;
+    }
+
+    free(l);
+    return list;
+}
+
+struct dlist *dlist_find_data(struct dlist *list, void *data)
+{
+    struct dlist *l;
+    void *_data;
+
+    dlist_foreach(list, l, _data) {
+	if (data == _data) {
+	    return l;
+	}
+    }
+
+    return NULL;
+}
+
+void *dlist_data(struct dlist *l)
+{
+    return l ? l->data : NULL;
+}
+
+struct dlist *dlist_next(struct dlist *l)
+{
+    return l ? l->next : NULL;
+}
+
+struct dlist *dlist_prev(struct dlist *l)
+{
+    return l ? l->prev : NULL;
+}
+
+int dlist_count(struct dlist *l)
+{
+    register int i;
+    struct dlist *n;
+    void *data;
+
+    i = 0;
+    dlist_foreach(l, n, data) {
+	i++;
+    }
+
+    return i;
+}
+
+struct dlist *dlist_nth(struct dlist *l, int nth)
+{
+    register int i;
+    struct dlist *n;
+    void *data;
+
+    i = 0;
+    dlist_foreach(l, n, data) {
+	if (i == nth) {
+	    return l;
+	}
+
+	i++;
+    }
+
+    return NULL;
+}
+
+/* End of a file */
diff --git a/dynamicbox/src/dynamicbox.c b/dynamicbox/src/dynamicbox.c
new file mode 100644
index 0000000..3bb52af
--- /dev/null
+++ b/dynamicbox/src/dynamicbox.c
@@ -0,0 +1,1367 @@
+/*
+ * Copyright 2013  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h> /* malloc */
+#include <string.h> /* strdup */
+#include <libgen.h>
+#include <unistd.h> /* access */
+#define __USE_GNU
+#include <dlfcn.h>
+
+#include <dlog.h>
+#include <dynamicbox_errno.h>
+#include <dynamicbox_service.h>
+#include <dynamicbox_provider.h>
+#include <dynamicbox_provider_buffer.h>
+#include <dynamicbox_conf.h>
+#include <dynamicbox_buffer.h>
+#include <Evas.h>
+#include <Ecore.h>
+
+#include "debug.h"
+#include "dlist.h"
+#include "util.h"
+#include "dynamicbox.h"
+#include "internal/dynamicbox.h"
+
+#define PUBLIC __attribute__((visibility("default")))
+
+#define FILE_SCHEMA    "file://"
+
+/**
+ * @note
+ * This value is configurable value.
+ */
+#define FRAME_WAIT_INTERVAL (1.0f/6.0f)
+
+struct block {
+    unsigned int idx;
+
+    char *type;
+    char *part;
+    char *data;
+    char *option;
+    char *id;
+    char *file;
+    char *target_id;
+};
+
+struct dynamicbox_desc {
+    FILE *fp;
+    int for_pd;
+
+    unsigned int last_idx;
+
+    struct dlist *block_list;
+};
+
+struct dynamicbox_buffer_data {
+    int is_gbar;
+    int accelerated;
+
+    /* for Buffer event wrapper */
+    int (*handler)(dynamicbox_buffer_h , dynamicbox_buffer_event_data_t, void *);
+    void *cbdata;
+
+    char *content;
+    char *title;
+    char *icon;
+    char *name;
+
+    Ecore_Timer *frame_wait_timer;
+};
+
+/**
+ * @brief These functions are defined in the data-provider-slave
+ */
+static struct info {
+    const char *(*find_pkgname)(const char *filename);
+    int (*request_update_by_id)(const char *uri);
+    int (*trigger_update_monitor)(const char *id, int is_gbar);
+    int (*update_extra_info)(const char *id, const char *content, const char *title, const char *icon, const char *name);
+
+    enum load_type {
+	LOAD_TYPE_UNKNOWN = -1,
+	LOAD_TYPE_SLAVE   = 0,
+	LOAD_TYPE_APP     = 1
+    } type;
+
+    union _updated {
+	struct _slave {
+	    int (*send)(const char *pkgname, const char *id, dynamicbox_buffer_h handle, int idx, int x, int y, int w, int h, int gbar, const char *descfile);
+	} slave;
+
+	struct _app {
+	    int (*send)(dynamicbox_buffer_h handle, int idx, int x, int y, int w, int h, int gbar);
+	} app;
+    } updated;
+} s_info = {
+    .find_pkgname = NULL,
+    .request_update_by_id = NULL,
+    .trigger_update_monitor = NULL,
+    .update_extra_info = NULL,
+    .type = LOAD_TYPE_UNKNOWN,    /* Not initialized */
+};
+
+#define FUNC_PREFIX                               "dynamicbox_"
+#define FUNC_DYNAMICBOX_SEND_UPDATED              FUNC_PREFIX "send_buffer_updated"
+#define FUNC_DYNAMICBOX_PROVIDER_APP_UPDATED      FUNC_PREFIX "provider_app_buffer_updated"
+#define FUNC_DYNAMICBOX_FIND_PKGNAME              FUNC_PREFIX "find_pkgname"
+#define FUNC_DYNAMICBOX_REQUEST_UPDATE_BY_ID      FUNC_PREFIX "request_update_by_id"
+#define FUNC_DYNAMICBOX_TRIGGER_UPDATE_MONITOR    FUNC_PREFIX "trigger_update_monitor"
+#define FUNC_DYNAMICBOX_UPDATE_EXTRA_INFO         FUNC_PREFIX "update_extra_info"
+
+static inline void load_update_function(void)
+{
+    /* Must to be checked the slave function first. */
+    s_info.updated.slave.send = dlsym(RTLD_DEFAULT, FUNC_DYNAMICBOX_SEND_UPDATED);
+    if (s_info.updated.slave.send) {
+	s_info.type = LOAD_TYPE_SLAVE;
+	DbgPrint("Slave detected\n");
+    } else {
+	s_info.updated.app.send = dlsym(RTLD_DEFAULT, FUNC_DYNAMICBOX_PROVIDER_APP_UPDATED);
+	if (s_info.updated.app.send) {
+	    s_info.type = LOAD_TYPE_APP;
+	    DbgPrint("App detected\n");
+	}
+    }
+}
+
+static int send_updated(const char *pkgname, const char *id, dynamicbox_buffer_h handle, int idx, int x, int y, int w, int h, int gbar, const char *descfile)
+{
+    int ret = DBOX_STATUS_ERROR_INVALID_PARAMETER;
+
+    if (s_info.type == LOAD_TYPE_UNKNOWN) {
+	load_update_function();
+    }
+
+    if (s_info.type == LOAD_TYPE_APP) {
+	ret = s_info.updated.app.send(handle, idx, x, y, w, h, gbar);
+    } else if (s_info.type == LOAD_TYPE_SLAVE) {
+	/**
+	 * pkgname, id are used for finding handle of direct connection.
+	 */
+	ret = s_info.updated.slave.send(pkgname, id, handle, idx, x, y, w, h, gbar, descfile);
+    } else {
+	dynamicbox_damage_region_t region = {
+	    .x = x,
+	    .y = y,
+	    .w = w,
+	    .h = h,
+	};
+	ret = dynamicbox_provider_send_buffer_updated(handle, idx, &region, gbar, descfile);
+    }
+
+    return ret;
+}
+
+static char *id_to_uri(const char *id)
+{
+    char *uri;
+    int uri_len;
+
+    uri_len = strlen(id) + strlen(FILE_SCHEMA) + 1;
+
+    uri = malloc(uri_len);
+    if (!uri) {
+	return NULL;
+    }
+
+    snprintf(uri, uri_len, FILE_SCHEMA "%s", id);
+    return uri;
+}
+
+static inline int event_handler_wrapper(dynamicbox_buffer_h buffer, dynamicbox_buffer_event_data_t event_info, void *data)
+{
+    const char *pkgname;
+    const char *id;
+    struct dynamicbox_buffer_data *cbdata = data;
+    int ret;
+
+    pkgname = dynamicbox_provider_buffer_pkgname(buffer);
+    if (!pkgname) {
+	ErrPrint("pkgname is not valid\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    id = dynamicbox_provider_buffer_id(buffer);
+    if (!id) {
+	ErrPrint("id is not valid[%s]\n", pkgname);
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (cbdata->handler) {
+	ret = cbdata->handler(buffer, event_info, cbdata->cbdata);
+    } else {
+	ret = DBOX_STATUS_ERROR_FAULT;
+    }
+
+    switch (event_info->type) {
+	case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT:
+	case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_NEXT:
+	case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_PREV:
+	case DBOX_BUFFER_EVENT_ACCESS_ACTIVATE:
+	case DBOX_BUFFER_EVENT_ACCESS_ACTION_UP:
+	case DBOX_BUFFER_EVENT_ACCESS_ACTION_DOWN:
+	case DBOX_BUFFER_EVENT_ACCESS_SCROLL_UP:
+	case DBOX_BUFFER_EVENT_ACCESS_SCROLL_MOVE:
+	case DBOX_BUFFER_EVENT_ACCESS_SCROLL_DOWN:
+	case DBOX_BUFFER_EVENT_ACCESS_UNHIGHLIGHT:
+	case DBOX_BUFFER_EVENT_ACCESS_VALUE_CHANGE:
+	case DBOX_BUFFER_EVENT_ACCESS_MOUSE:
+	case DBOX_BUFFER_EVENT_ACCESS_BACK:
+	case DBOX_BUFFER_EVENT_ACCESS_OVER:
+	case DBOX_BUFFER_EVENT_ACCESS_READ:
+	case DBOX_BUFFER_EVENT_ACCESS_ENABLE:
+	case DBOX_BUFFER_EVENT_ACCESS_DISABLE:
+	    DbgPrint("Accessibility event: %d\n", event_info->type);
+	    if (ret < 0) {
+		(void)dynamicbox_provider_send_access_status(pkgname, id, DBOX_ACCESS_STATUS_ERROR);
+	    } else {
+		(void)dynamicbox_provider_send_access_status(pkgname, id, ret);
+	    }
+	    break;
+	case DBOX_BUFFER_EVENT_KEY_UP:
+	case DBOX_BUFFER_EVENT_KEY_DOWN:
+	case DBOX_BUFFER_EVENT_KEY_FOCUS_IN:
+	case DBOX_BUFFER_EVENT_KEY_FOCUS_OUT:
+	    DbgPrint("Key event: %d\n", event_info->type);
+	    if (ret < 0) {
+		(void)dynamicbox_provider_send_key_status(pkgname, id, DBOX_KEY_STATUS_ERROR);
+	    } else {
+		(void)dynamicbox_provider_send_key_status(pkgname, id, ret);
+	    }
+	    break;
+	default:
+	    break;
+    }
+
+    return ret;
+}
+
+static inline int default_event_handler(dynamicbox_buffer_h buffer, dynamicbox_buffer_event_data_t event_info, void *data)
+{
+    /* NOP */
+    return 0;
+}
+
+PUBLIC const int DBOX_DONE = 0x00;
+PUBLIC const int DBOX_OUTPUT_UPDATED = 0x02;
+PUBLIC const int DBOX_USE_NET = 0x04;
+
+PUBLIC const int DBOX_NEED_TO_SCHEDULE = 0x01;
+PUBLIC const int DBOX_NEED_TO_CREATE = 0x01;
+PUBLIC const int DBOX_NEED_TO_DESTROY = 0x01;
+PUBLIC const int DBOX_FORCE_TO_SCHEDULE = 0x08;
+
+PUBLIC const int DBOX_SYS_EVENT_FONT_CHANGED = 0x01;
+PUBLIC const int DBOX_SYS_EVENT_LANG_CHANGED = 0x02;
+PUBLIC const int DBOX_SYS_EVENT_TIME_CHANGED = 0x04;
+PUBLIC const int DBOX_SYS_EVENT_REGION_CHANGED = 0x08;
+PUBLIC const int DBOX_SYS_EVENT_TTS_CHANGED = 0x10;
+PUBLIC const int DBOX_SYS_EVENT_PAUSED = 0x0100;
+PUBLIC const int DBOX_SYS_EVENT_RESUMED = 0x0200;
+PUBLIC const int DBOX_SYS_EVENT_MMC_STATUS_CHANGED = 0x0400;
+PUBLIC const int DBOX_SYS_EVENT_DELETED = 0x0800;
+
+PUBLIC struct dynamicbox_desc *dynamicbox_desc_open(const char *filename, int for_pd)
+{
+    struct dynamicbox_desc *handle;
+    char *new_fname;
+
+    handle = calloc(1, sizeof(*handle));
+    if (!handle) {
+	ErrPrint("Error: %s\n", strerror(errno));
+	return NULL;
+    }
+
+    if (for_pd) {
+	int len;
+	len = strlen(filename) + strlen(".desc") + 1;
+	new_fname = malloc(len);
+	if (!new_fname) {
+	    ErrPrint("Error: %s\n", strerror(errno));
+	    free(handle);
+	    return NULL;
+	}
+	snprintf(new_fname, len, "%s.desc", filename);
+    } else {
+	new_fname = strdup(filename);
+	if (!new_fname) {
+	    ErrPrint("Error: %s\n", strerror(errno));
+	    free(handle);
+	    return NULL;
+	}
+    }
+
+    DbgPrint("Open a file %s with merge mode %s\n",
+	    new_fname,
+	    access(new_fname, F_OK) == 0 ? "enabled" : "disabled");
+
+    handle->fp = fopen(new_fname, "at");
+    free(new_fname);
+    if (!handle->fp) {
+	ErrPrint("Failed to open a file: %s\n", strerror(errno));
+	free(handle);
+	return NULL;
+    }
+
+    return handle;
+}
+
+PUBLIC int dynamicbox_desc_close(struct dynamicbox_desc *handle)
+{
+    struct dlist *l;
+    struct dlist *n;
+    struct block *block;
+
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    dlist_foreach_safe(handle->block_list, l, n, block) {
+	handle->block_list = dlist_remove(handle->block_list, l);
+
+	fprintf(handle->fp, "{\n");
+	if (block->type) {
+	    fprintf(handle->fp, "type=%s\n", block->type);
+	}
+
+	if (block->part) {
+	    fprintf(handle->fp, "part=%s\n", block->part);
+	}
+
+	if (block->data) {
+	    fprintf(handle->fp, "data=%s\n", block->data);
+	}
+
+	if (block->option) {
+	    fprintf(handle->fp, "option=%s\n", block->option);
+	}
+
+	if (block->id) {
+	    fprintf(handle->fp, "id=%s\n", block->id);
+	}
+
+	if (block->target_id) {
+	    fprintf(handle->fp, "target=%s\n", block->target_id);
+	}
+	fprintf(handle->fp, "}\n");
+
+	free(block->type);
+	free(block->part);
+	free(block->data);
+	free(block->option);
+	free(block->id);
+	free(block->target_id);
+	free(block);
+    }
+
+    if (fclose(handle->fp) != 0) {
+	ErrPrint("fclose: %s\n", strerror(errno));
+    }
+    free(handle);
+    return DBOX_STATUS_ERROR_NONE;
+}
+
+PUBLIC int dynamicbox_desc_set_category(struct dynamicbox_desc *handle, const char *id, const char *category)
+{
+    struct block *block;
+
+    if (!handle || !category) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    block = calloc(1, sizeof(*block));
+    if (!block) {
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->type = strdup(DBOX_DESC_TYPE_INFO);
+    if (!block->type) {
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->part = strdup("category");
+    if (!block->part) {
+	free(block->type);
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->data = strdup(category);
+    if (!block->data) {
+	free(block->type);
+	free(block->part);
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (id) {
+	block->id = strdup(id);
+	if (!block->id) {
+	    free(block->data);
+	    free(block->type);
+	    free(block->part);
+	    free(block);
+	    return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+	}
+    }
+
+    block->idx = handle->last_idx++;
+    handle->block_list = dlist_append(handle->block_list, block);
+    return block->idx;
+}
+
+PUBLIC int dynamicbox_desc_set_size(struct dynamicbox_desc *handle, const char *id, int w, int h)
+{
+    struct block *block;
+    char buffer[BUFSIZ];
+
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    block = calloc(1, sizeof(*block));
+    if (!block) {
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->type = strdup(DBOX_DESC_TYPE_INFO);
+    if (!block->type) {
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->part = strdup("size");
+    if (!block->part) {
+	free(block->type);
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (id) {
+	block->id = strdup(id);
+	if (!block->id) {
+	    free(block->part);
+	    free(block->type);
+	    free(block);
+	    return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+	}
+    }
+
+    snprintf(buffer, sizeof(buffer), "%dx%d", w, h);
+    block->data = strdup(buffer);
+    if (!block->data) {
+	free(block->id);
+	free(block->part);
+	free(block->type);
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->idx = handle->last_idx++;
+    handle->block_list = dlist_append(handle->block_list, block);
+    return block->idx;
+}
+
+PUBLIC int dynamicbox_desc_set_id(struct dynamicbox_desc *handle, int idx, const char *id)
+{
+    struct dlist *l;
+    struct block *block;
+
+    dlist_foreach(handle->block_list, l, block) {
+	if (block->idx == idx) {
+	    if (strcasecmp(block->type, DBOX_DESC_TYPE_SCRIPT)) {
+		ErrPrint("Invalid block is used\n");
+		return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+	    }
+
+	    free(block->target_id);
+	    block->target_id = NULL;
+
+	    if (!id || !strlen(id)) {
+		return DBOX_STATUS_ERROR_NONE;
+	    }
+
+	    block->target_id = strdup(id);
+	    if (!block->target_id) {
+		ErrPrint("Heap: %s\n", strerror(errno));
+		return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+	    }
+
+	    return DBOX_STATUS_ERROR_NONE;
+	}
+    }
+
+    return DBOX_STATUS_ERROR_NOT_EXIST;
+}
+
+/*!
+ * \return idx
+ */
+PUBLIC int dynamicbox_desc_add_block(struct dynamicbox_desc *handle, const char *id, const char *type, const char *part, const char *data, const char *option)
+{
+    struct block *block;
+
+    if (!handle || !type) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (!part) {
+	part = "";
+    }
+
+    if (!data) {
+	data = "";
+    }
+
+    block = calloc(1, sizeof(*block));
+    if (!block) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->type = strdup(type);
+    if (!block->type) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->part = strdup(part);
+    if (!block->part) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	free(block->type);
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    block->data = strdup(data);
+    if (!block->data) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	free(block->type);
+	free(block->part);
+	free(block);
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (option) {
+	block->option = strdup(option);
+	if (!block->option) {
+	    ErrPrint("Heap: %s\n", strerror(errno));
+	    free(block->data);
+	    free(block->type);
+	    free(block->part);
+	    free(block);
+	    return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+	}
+    }
+
+    if (id) {
+	block->id = strdup(id);
+	if (!block->id) {
+	    ErrPrint("Heap: %s\n", strerror(errno));
+	    free(block->option);
+	    free(block->data);
+	    free(block->type);
+	    free(block->part);
+	    free(block);
+	    return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+	}
+    }
+
+    block->idx = handle->last_idx++;
+    handle->block_list = dlist_append(handle->block_list, block);
+    return block->idx;
+}
+
+PUBLIC int dynamicbox_desc_del_block(struct dynamicbox_desc *handle, int idx)
+{
+    struct dlist *l;
+    struct block *block;
+
+    if (!handle || idx < 0) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    dlist_foreach(handle->block_list, l, block) {
+	if (block->idx == idx) {
+	    handle->block_list = dlist_remove(handle->block_list, l);
+	    free(block->type);
+	    free(block->part);
+	    free(block->data);
+	    free(block->option);
+	    free(block->id);
+	    free(block->target_id);
+	    free(block);
+	    return DBOX_STATUS_ERROR_NONE;
+	}
+    }
+
+    return DBOX_STATUS_ERROR_NOT_EXIST;
+}
+
+PUBLIC int dynamicbox_acquire_buffer(dynamicbox_buffer_h handle, int idx, int width, int height, int pixel_size)
+{
+    int ret;
+
+    if (!handle || width <= 0 || height <= 0 || pixel_size <= 0 || idx > DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (idx >= 0) {
+	int _width = 0;
+	int _height = 0;
+	int _pixel_size = 0;
+	/* To validate the buffer */
+	if (dynamicbox_provider_buffer_get_size(handle, &_width, &_height, &_pixel_size) < 0) {
+	    ErrPrint("Failed to get buffer size\n");
+	}
+
+	if (_width != width || _height != height || pixel_size != _pixel_size) {
+	    DbgPrint("Extra buffer's geometry is not matched with primary one\n");
+	}
+
+	ret = dynamicbox_provider_buffer_extra_acquire(handle, idx, width, height, pixel_size);
+    } else {
+	ret = dynamicbox_provider_buffer_acquire(handle, width, height, pixel_size);
+    }
+
+    return ret;
+}
+
+PUBLIC dynamicbox_buffer_h dynamicbox_create_buffer(const char *filename, int is_gbar, int auto_align, int (*handler)(dynamicbox_buffer_h , dynamicbox_buffer_event_data_t, void *), void *data)
+{
+    struct dynamicbox_buffer_data *user_data;
+    const char *pkgname;
+    dynamicbox_buffer_h handle;
+    char *uri;
+
+    if (!filename) {
+	ErrPrint("Invalid argument: %p(%dx%d)\n", filename);
+	return NULL;
+    }
+
+    user_data = calloc(1, sizeof(*user_data));
+    if (!user_data) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return NULL;
+    }
+
+    user_data->is_gbar = is_gbar;
+    user_data->handler = handler ? handler : default_event_handler;
+    user_data->cbdata = data;
+
+    uri = id_to_uri(filename);
+    if (!uri) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	free(user_data);
+	return NULL;
+    }
+
+    if (!s_info.find_pkgname) {
+	s_info.find_pkgname = dlsym(RTLD_DEFAULT, FUNC_DYNAMICBOX_FIND_PKGNAME);
+	if (!s_info.find_pkgname) {
+	    ErrPrint("Failed to find a \"dynamicbox_find_pkgname\"\n");
+	    free(user_data);
+	    free(uri);
+	    return NULL;
+	}
+    }
+
+    pkgname = s_info.find_pkgname(uri);
+    if (!pkgname) {
+	ErrPrint("Invalid Request\n");
+	free(user_data);
+	free(uri);
+	return NULL;
+    }
+
+    handle = dynamicbox_provider_buffer_create((!!is_gbar) ? DBOX_TYPE_GBAR : DBOX_TYPE_DBOX, pkgname, uri, auto_align, event_handler_wrapper, user_data);
+    free(uri);
+    if (!handle) {
+	free(user_data);
+	return NULL;
+    }
+
+    (void)dynamicbox_provider_buffer_set_user_data(handle, user_data);
+    return handle;
+}
+
+PUBLIC int dynamicbox_request_update(const char *filename)
+{
+    char *uri;
+    int ret;
+
+    if (!filename) {
+	ErrPrint("Invalid argument\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    uri = id_to_uri(filename);
+    if (!uri) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (!s_info.request_update_by_id) {
+	s_info.request_update_by_id = dlsym(RTLD_DEFAULT, FUNC_DYNAMICBOX_REQUEST_UPDATE_BY_ID);
+	if (!s_info.request_update_by_id) {
+	    ErrPrint("\"dynamicbox_request_update_by_id\" is not exists\n");
+	    free(uri);
+	    return DBOX_STATUS_ERROR_FAULT;
+	}
+    }
+
+    ret = s_info.request_update_by_id(uri);
+    free(uri);
+    return ret;
+}
+
+PUBLIC unsigned int dynamicbox_resource_id(dynamicbox_buffer_h handle, int idx)
+{
+    int ret;
+
+    if (!handle || idx > DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (idx >= 0) {
+	ret = dynamicbox_provider_buffer_extra_resource_id(handle, idx);
+    } else {
+	ret = dynamicbox_provider_buffer_resource_id(handle);
+    }
+
+    return ret;
+}
+
+PUBLIC int dynamicbox_release_buffer(dynamicbox_buffer_h handle, int idx)
+{
+    int ret;
+
+    if (!handle || idx > DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (idx >= 0) {
+	ret = dynamicbox_provider_buffer_extra_release(handle, idx);
+    } else {
+	ret = dynamicbox_provider_buffer_release(handle);
+    }
+
+    DbgPrint("Release buffer: %d (%d)\n", idx, ret);
+    return ret;
+}
+
+PUBLIC int dynamicbox_destroy_buffer(dynamicbox_buffer_h handle)
+{
+    struct dynamicbox_buffer_data *user_data;
+
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (user_data) {
+	if (user_data->frame_wait_timer) {
+	    ecore_timer_del(user_data->frame_wait_timer);
+	    user_data->frame_wait_timer = NULL;
+	}
+	free(user_data->content);
+	free(user_data->title);
+	free(user_data->icon);
+	free(user_data->name);
+	free(user_data);
+	dynamicbox_provider_buffer_set_user_data(handle, NULL);
+    }
+
+    DbgPrint("Destroy buffer\n");
+    return dynamicbox_provider_buffer_destroy(handle);
+}
+
+PUBLIC void *dynamicbox_ref_buffer(dynamicbox_buffer_h handle)
+{
+    struct dynamicbox_buffer_data *user_data;
+    void *data;
+    int w, h, size;
+    int ret;
+
+    if (!handle) {
+	return NULL;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data) {
+	return NULL;
+    }
+
+    if (user_data->accelerated) {
+	DbgPrint("H/W accelerated buffer is allocated\n");
+	return NULL;
+    }
+
+    ret = dynamicbox_provider_buffer_get_size(handle, &w, &h, &size);
+
+    data = dynamicbox_provider_buffer_ref(handle);
+    if (data && !ret && w > 0 && h > 0 && size > 0) {
+	memset(data, 0, w * h * size);
+	(void)dynamicbox_provider_buffer_sync(handle);
+    }
+
+    DbgPrint("Ref buffer %ds%d(%d)\n", w, h, size);
+    return data;
+}
+
+PUBLIC int dynamicbox_unref_buffer(void *buffer)
+{
+    if (!buffer) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    DbgPrint("Unref buffer\n");
+    return dynamicbox_provider_buffer_unref(buffer);
+}
+
+PUBLIC int dynamicbox_sync_buffer(dynamicbox_buffer_h handle)
+{
+    struct dynamicbox_buffer_data *user_data;
+    const char *pkgname;
+    const char *id;
+    int w;
+    int h;
+    int pixel_size;
+    int ret;
+
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data) {
+	ErrPrint("Invalid buffer\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (user_data->accelerated) {
+	DbgPrint("H/W Buffer allocated. skip the sync buffer\n");
+	return DBOX_STATUS_ERROR_NONE;
+    }
+
+    pkgname = dynamicbox_provider_buffer_pkgname(handle);
+    if (!pkgname) {
+	ErrPrint("Invalid buffer handler\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    id = dynamicbox_provider_buffer_id(handle);
+    if (!id) {
+	ErrPrint("Invalid buffer handler\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    (void)dynamicbox_provider_buffer_sync(handle);
+
+    if (dynamicbox_provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0) {
+	ErrPrint("Failed to get size (%s)\n", id);
+    }
+
+    /**
+     * @todo
+     * manipulate the damaged region, so send update event only for the damaged region.
+     * to make more efficient updates
+     */
+    ret = send_updated(pkgname, id, handle, DBOX_PRIMARY_BUFFER, 0, 0, w, h, user_data->is_gbar, NULL);
+    if (ret < 0) {
+	ErrPrint("Failed to send%supdated (%s)\n", user_data->is_gbar ? " GBAR " : " ", id);
+    }
+
+    return ret;
+}
+
+PUBLIC int dynamicbox_send_updated_by_idx(dynamicbox_buffer_h handle, int idx)
+{
+    struct dynamicbox_buffer_data *user_data;
+    const char *pkgname;
+    const char *id;
+    int w;
+    int h;
+    int pixel_size;
+    int ret;
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data) {
+	ErrPrint("Invalid buffer\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    pkgname = dynamicbox_provider_buffer_pkgname(handle);
+    if (!pkgname) {
+	ErrPrint("Invalid buffer handler\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    id = dynamicbox_provider_buffer_id(handle);
+    if (!id) {
+	ErrPrint("Invalid buffer handler\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (dynamicbox_provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0) {
+	ErrPrint("Failed to get size (%s)\n", id);
+    }
+
+    ret = send_updated(pkgname, id, handle, idx, 0, 0, w, h, user_data->is_gbar, NULL);
+    if (ret < 0) {
+	ErrPrint("Failed to send%supdated (%s) %d\n", user_data->is_gbar ? " GBAR " : " ", id, idx);
+    }
+
+    return ret;
+}
+
+PUBLIC int dynamicbox_support_hw_buffer(dynamicbox_buffer_h handle)
+{
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    return dynamicbox_provider_buffer_is_support_hw(handle);
+}
+
+PUBLIC int dynamicbox_create_hw_buffer(dynamicbox_buffer_h handle)
+{
+    struct dynamicbox_buffer_data *user_data;
+    int ret;
+
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (user_data->accelerated) {
+	return DBOX_STATUS_ERROR_ALREADY;
+    }
+
+    ret = dynamicbox_provider_buffer_create_hw(handle);
+    user_data->accelerated = (ret == 0);
+    return ret;
+}
+
+PUBLIC int dynamicbox_destroy_hw_buffer(dynamicbox_buffer_h handle)
+{
+    struct dynamicbox_buffer_data *user_data;
+
+    if (!handle) {
+	LOGD("handle is NULL\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data || !user_data->accelerated) {
+	LOGD("user_data is NULL\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    user_data->accelerated = 0;
+
+    return dynamicbox_provider_buffer_destroy_hw(handle);
+}
+
+PUBLIC void *dynamicbox_buffer_hw_buffer(dynamicbox_buffer_h handle)
+{
+    struct dynamicbox_buffer_data *user_data;
+
+    if (!handle) {
+	return NULL;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data || !user_data->accelerated) {
+	return NULL;
+    }
+
+    return dynamicbox_provider_buffer_hw_addr(handle);
+}
+
+PUBLIC int dynamicbox_buffer_pre_render(dynamicbox_buffer_h handle)
+{
+    struct dynamicbox_buffer_data *user_data;
+
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (!user_data->accelerated) {
+	return DBOX_STATUS_ERROR_NONE;
+    }
+
+    /*!
+     * \note
+     * Do preprocessing for accessing the H/W render buffer
+     */
+    return dynamicbox_provider_buffer_pre_render(handle);
+}
+
+static Eina_Bool frame_wait_cb(void *data)
+{
+    dynamicbox_buffer_h handle = data;
+    struct dynamicbox_buffer_data *user_data;
+    const char *pkgname;
+    const char *id;
+    int pixel_size;
+    int ret;
+    int w;
+    int h;
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data) {
+	ErrPrint("Failed to get a user data\n");
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    pkgname = dynamicbox_provider_buffer_pkgname(handle);
+    id = dynamicbox_provider_buffer_id(handle);
+
+    if (!pkgname || !id) {
+	ErrPrint("Failed to get instance information (%s), (%s)\n", pkgname, id);
+	user_data->frame_wait_timer = NULL;
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    if (dynamicbox_provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0) {
+	ErrPrint("Failed to get size (%s)\n", id);
+	w = 0;
+	h = 0;
+	pixel_size = sizeof(int);
+    }
+
+    DbgPrint("Frame skip waiting timer is fired (%s)\n", id);
+
+    /**
+     * @todo
+     * manipulate the damaged region, so send update event only for the damaged region.
+     * to make more efficient updates
+     */
+    ret = send_updated(pkgname, id, handle, DBOX_PRIMARY_BUFFER, 0, 0, w, h, user_data->is_gbar, NULL);
+    if (ret < 0) {
+	ErrPrint("Failed to send%supdated (%s)\n", user_data->is_gbar ? " GBAR " : " ", id);
+    }
+
+    (void)dynamicbox_provider_buffer_clear_frame_skip(handle);
+
+    user_data->frame_wait_timer = NULL;
+    return ECORE_CALLBACK_CANCEL;
+}
+
+PUBLIC int dynamicbox_buffer_post_render(dynamicbox_buffer_h handle)
+{
+    int ret;
+    const char *pkgname;
+    const char *id;
+    struct dynamicbox_buffer_data *user_data;
+    int w;
+    int h;
+    int pixel_size;
+    PERF_INIT();
+    PERF_BEGIN();
+
+    if (!handle) {
+	PERF_MARK("post_render");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    user_data = dynamicbox_provider_buffer_user_data(handle);
+    if (!user_data) {
+	PERF_MARK("post_render");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (!user_data->accelerated) {
+	PERF_MARK("post_render");
+	return DBOX_STATUS_ERROR_NONE;
+    }
+
+    pkgname = dynamicbox_provider_buffer_pkgname(handle);
+    if (!pkgname) {
+	ErrPrint("Invalid buffer handle\n");
+	PERF_MARK("post_render");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    id = dynamicbox_provider_buffer_id(handle);
+    if (!id) {
+	ErrPrint("Invalid buffer handler\n");
+	PERF_MARK("post_render");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    ret = dynamicbox_provider_buffer_post_render(handle);
+    if (ret < 0) {
+	ErrPrint("Failed to post render processing\n");
+	PERF_MARK("post_render");
+	return ret;
+    }
+
+    if (dynamicbox_provider_buffer_frame_skip(handle) == 0) {
+	if (dynamicbox_provider_buffer_get_size(handle, &w, &h, &pixel_size) < 0) {
+	    ErrPrint("Failed to get size (%s)\n", id);
+	}
+
+	/**
+	 * @todo
+	 * manipulate the damaged region, so send update event only for the damaged region.
+	 * to make more efficient updates
+	 */
+	ret = send_updated(pkgname, id, handle, DBOX_PRIMARY_BUFFER, 0, 0, w, h, user_data->is_gbar, NULL);
+	if (ret < 0) {
+	    ErrPrint("Failed to send%supdated (%s)\n", user_data->is_gbar ? " GBAR " : " ", id);
+	}
+
+	if (user_data->frame_wait_timer) {
+	    ecore_timer_del(user_data->frame_wait_timer);
+	    user_data->frame_wait_timer = NULL;
+	}
+    } else {
+	if (user_data->frame_wait_timer) {
+	    ecore_timer_reset(user_data->frame_wait_timer);
+	} else {
+	    user_data->frame_wait_timer = ecore_timer_add(FRAME_WAIT_INTERVAL, frame_wait_cb, handle);
+	    if (!user_data->frame_wait_timer) {
+		ErrPrint("Failed to add waiting timer for next frame\n");
+	    }
+	}
+    }
+
+    PERF_MARK("post_render");
+    return ret;
+}
+
+PUBLIC int dynamicbox_buffer_stride(dynamicbox_buffer_h handle)
+{
+    if (!handle) {
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    return dynamicbox_provider_buffer_stride(handle);
+}
+
+PUBLIC int dynamicbox_content_is_updated(const char *filename, int is_gbar)
+{
+    if (!s_info.trigger_update_monitor) {
+	s_info.trigger_update_monitor = dlsym(RTLD_DEFAULT, FUNC_DYNAMICBOX_TRIGGER_UPDATE_MONITOR);
+	if (!s_info.trigger_update_monitor) {
+	    ErrPrint("Trigger update monitor function is not exists\n");
+	    return DBOX_STATUS_ERROR_FAULT;
+	}
+    }
+
+    return s_info.trigger_update_monitor(filename, is_gbar);
+}
+
+PUBLIC int dynamicbox_request_close_glance_bar(const char *pkgname, const char *id, int reason)
+{
+    char *uri;
+    int schema_len = strlen(FILE_SCHEMA);
+    int ret;
+
+    if (!pkgname || !id) {
+	ErrPrint("Invalid parameters (%s) (%s)\n", pkgname, id);
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    if (strncmp(id, FILE_SCHEMA, schema_len)) {
+	uri = id_to_uri(id);
+	if (!uri) {
+	    ErrPrint("Heap: %s\n", strerror(errno));
+	    return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+	}
+    } else {
+	uri = strdup(id);
+	if (!uri) {
+	    ErrPrint("Heap: %s\n", strerror(errno));
+	    return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+	}
+    }
+
+    ret = dynamicbox_provider_send_request_close_gbar(pkgname, uri, reason);
+    free(uri);
+    return ret;
+}
+
+PUBLIC int dynamicbox_freeze_scroller(const char *pkgname, const char *id)
+{
+    char *uri;
+    int ret;
+
+    uri = id_to_uri(id);
+    if (!uri) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    ret = dynamicbox_provider_send_hold_scroll(pkgname, uri, 1);
+    free(uri);
+    return ret;
+}
+
+PUBLIC int dynamicbox_thaw_scroller(const char *pkgname, const char *id)
+{
+    char *uri;
+    int ret;
+
+    uri = id_to_uri(id);
+    if (!uri) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    ret = dynamicbox_provider_send_hold_scroll(pkgname, uri, 0);
+    free(uri);
+    return ret;
+}
+
+PUBLIC int dynamicbox_set_extra_info(const char *id, const char *content, const char *title, const char *icon, const char *name)
+{
+    dynamicbox_buffer_h handle;
+    const char *pkgname;
+    char *uri;
+
+    uri = id_to_uri(id);
+    if (!uri) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return DBOX_STATUS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (!s_info.find_pkgname) {
+	s_info.find_pkgname = dlsym(RTLD_DEFAULT, FUNC_DYNAMICBOX_FIND_PKGNAME);
+	if (!s_info.find_pkgname) {
+	    ErrPrint("Failed to find a \"dynamicbox_find_pkgname\"\n");
+	    free(uri);
+	    return DBOX_STATUS_ERROR_FAULT;
+	}
+    }
+
+    pkgname = s_info.find_pkgname(uri);
+    if (!pkgname) {
+	ErrPrint("Failed to find a package (%s)\n", uri);
+	free(uri);
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    handle = dynamicbox_provider_buffer_find_buffer(DBOX_TYPE_DBOX, pkgname, uri);
+    if (handle) {
+	struct dynamicbox_buffer_data *user_data;
+
+	user_data = dynamicbox_provider_buffer_user_data(handle);
+	if (!user_data) {
+	    ErrPrint("User data is not available\n");
+	    free(uri);
+	    return DBOX_STATUS_ERROR_FAULT;
+	}
+
+	if (content && strlen(content)) {
+	    char *_content;
+
+	    _content = strdup(content);
+	    if (_content) {
+		if (user_data->content) {
+		    free(user_data->content);
+		}
+
+		user_data->content = _content;
+	    } else {
+		ErrPrint("Heap: %s\n", strerror(errno));
+	    }
+	}
+
+	if (title && strlen(title)) {
+	    char *_title;
+
+	    _title = strdup(title);
+	    if (_title) {
+		if (user_data->title) {
+		    free(user_data->title);
+		}
+
+		user_data->title = _title;
+	    } else {
+		ErrPrint("Heap: %s\n", strerror(errno));
+	    }
+	}
+
+	if (icon && strlen(icon)) {
+	    char *_icon;
+
+	    _icon = strdup(icon);
+	    if (_icon) {
+		if (user_data->icon) {
+		    free(user_data->icon);
+		}
+
+		user_data->icon = _icon;
+	    } else {
+		ErrPrint("Heap: %s\n", strerror(errno));
+	    }
+	}
+
+	if (name && strlen(name)) {
+	    char *_name;
+
+	    _name = strdup(name);
+	    if (_name) {
+		if (user_data->name) {
+		    free(user_data->name);
+		}
+
+		user_data->name = _name;
+	    } else {
+		ErrPrint("Heap: %s\n", strerror(errno));
+	    }
+	}
+
+	if (dynamicbox_provider_send_extra_info(pkgname, uri, -1.0f, user_data->content, user_data->title, user_data->icon, user_data->name) < 0) {
+	    ErrPrint("Failed to send extra info (%s)\n", id);
+	}
+
+	free(uri);
+	return DBOX_STATUS_ERROR_NONE;
+    }
+    free(uri);
+
+    if (!s_info.update_extra_info) {
+	s_info.update_extra_info = dlsym(RTLD_DEFAULT, FUNC_DYNAMICBOX_UPDATE_EXTRA_INFO);
+	if (!s_info.update_extra_info) {
+	    ErrPrint("Failed to find a \"dynamicbox_update_extra_info\"\n");
+	    return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+	}
+    }
+
+    return s_info.update_extra_info(id, content, title, icon, name);
+}
+
+/* End of a file */
diff --git a/dynamicbox/src/snapshot_window.c b/dynamicbox/src/snapshot_window.c
new file mode 100644
index 0000000..0956faf
--- /dev/null
+++ b/dynamicbox/src/snapshot_window.c
@@ -0,0 +1,502 @@
+/*
+ * Copyright 2013  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <Elementary.h>
+#include <Ecore_Evas.h>
+#include <Evas.h>
+#include <Ecore.h>
+#include <unistd.h>
+
+#include <dlog.h>
+#include <dynamicbox_service.h>
+#include <dynamicbox_errno.h>
+
+#include "dynamicbox.h"
+#include "internal/dynamicbox.h"
+#include "debug.h"
+
+#define QUALITY_N_COMPRESS "quality=100 compress=1"
+#define PUBLIC __attribute__((visibility("default")))
+
+struct snapshot_info {
+    char *id;
+    dynamicbox_flush_cb flush_cb;
+    void *data;
+
+    Ecore_Timer *flush_timer;
+
+    int render_cnt;
+    double timeout;
+};
+
+static void post_render_cb(void *data, Evas *e, void *event_info);
+static void pre_render_cb(void *data, Evas *e, void *event_info);
+
+static inline Evas *create_virtual_canvas(int w, int h)
+{
+    Ecore_Evas *internal_ee;
+    Evas *internal_e;
+
+    // Create virtual canvas
+    internal_ee = ecore_evas_buffer_new(w, h);
+    if (!internal_ee) {
+	DbgPrint("Failed to create a new canvas buffer\n");
+	return NULL;
+    }
+
+    ecore_evas_alpha_set(internal_ee, EINA_TRUE);
+    ecore_evas_manual_render_set(internal_ee, EINA_FALSE);
+
+    // Get the "Evas" object from a virtual canvas
+    internal_e = ecore_evas_get(internal_ee);
+    if (!internal_e) {
+	ecore_evas_free(internal_ee);
+	DbgPrint("Faield to get Evas object\n");
+	return NULL;
+    }
+
+    return internal_e;
+}
+
+static inline int flush_data_to_file(Evas *e, const char *data, const char *filename, int w, int h)
+{
+    Evas_Object *output;
+
+    output = evas_object_image_add(e);
+    if (!output) {
+	DbgPrint("Failed to create an image object\n");
+	return DBOX_STATUS_ERROR_FAULT;
+    }
+
+    evas_object_image_data_set(output, NULL);
+    evas_object_image_colorspace_set(output, EVAS_COLORSPACE_ARGB8888);
+    evas_object_image_alpha_set(output, EINA_TRUE);
+    evas_object_image_size_set(output, w, h);
+    evas_object_image_smooth_scale_set(output, EINA_TRUE);
+    evas_object_image_data_set(output, (void *)data);
+    evas_object_image_fill_set(output, 0, 0, w, h);
+    evas_object_image_data_update_add(output, 0, 0, w, h);
+
+    if (evas_object_image_save(output, filename, NULL, QUALITY_N_COMPRESS) == EINA_FALSE) {
+	evas_object_del(output);
+	DbgPrint("Faield to save a captured image (%s)\n", filename);
+	return DBOX_STATUS_ERROR_IO_ERROR;
+    }
+
+    evas_object_del(output);
+
+    if (access(filename, F_OK) != 0) {
+	DbgPrint("File %s is not found\n", filename);
+	return DBOX_STATUS_ERROR_IO_ERROR;
+    }
+
+    DbgPrint("Flush data to a file (%s)\n", filename);
+    return DBOX_STATUS_ERROR_NONE;
+}
+
+static inline int destroy_virtual_canvas(Evas *e)
+{
+    Ecore_Evas *ee;
+
+    ee = ecore_evas_ecore_evas_get(e);
+    if (!ee) {
+	DbgPrint("Failed to ecore evas object\n");
+	return DBOX_STATUS_ERROR_FAULT;
+    }
+
+    ecore_evas_free(ee);
+    return DBOX_STATUS_ERROR_NONE;
+}
+
+static inline int flush_to_file(const void *canvas, const char *filename, int w, int h)
+{
+    int status;
+    Evas *shot_e;
+    Ecore_Evas *shot_ee;
+
+    shot_e = create_virtual_canvas(w, h);
+    if (!shot_e) {
+	ErrPrint("Unable to create a new virtual window\n");
+	return DBOX_STATUS_ERROR_FAULT;
+    }
+
+    shot_ee = ecore_evas_ecore_evas_get(shot_e);
+    if (!shot_ee) {
+	ErrPrint("Unable to get Ecore_Evas\n");
+	destroy_virtual_canvas(shot_e);
+	return DBOX_STATUS_ERROR_FAULT;
+    }
+
+    ecore_evas_manual_render_set(shot_ee, EINA_TRUE);
+
+    status = flush_data_to_file(shot_e, canvas, filename, w, h);
+    destroy_virtual_canvas(shot_e);
+
+    return status;
+}
+
+static Eina_Bool snapshot_cb(void *data)
+{
+    Evas_Object *snapshot_win = data;
+    struct snapshot_info *info;
+    Evas *e;
+    Ecore_Evas *ee;
+    void *canvas;
+    dynamicbox_flush_cb flush_cb;
+    int status = DBOX_STATUS_ERROR_NONE;
+
+    info = evas_object_data_get(snapshot_win, "snapshot,info");
+    if (!info) {
+	ErrPrint("Invalid object\n");
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    if (info->flush_timer) {
+	info->flush_timer = NULL;
+    } else {
+	status = DBOX_STATUS_ERROR_CANCEL;
+    }
+
+    flush_cb = info->flush_cb;
+    info->flush_cb = NULL; /* To prevent call this from the delete callback */
+
+    e = evas_object_evas_get(snapshot_win);
+    if (!e) {
+	ErrPrint("Invalid object\n");
+	if (flush_cb) {
+	    flush_cb(snapshot_win, info->id, DBOX_STATUS_ERROR_FAULT, info->data);
+	}
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    ee = ecore_evas_ecore_evas_get(e);
+    if (!ee) {
+	ErrPrint("Invalid object (ee)\n");
+	if (flush_cb) {
+	    flush_cb(snapshot_win, info->id, DBOX_STATUS_ERROR_FAULT, info->data);
+	}
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    canvas = (void*)ecore_evas_buffer_pixels_get(ee);
+    if (!canvas) {
+	DbgPrint("Failed to get pixel canvas\n");
+	if (flush_cb) {
+	    flush_cb(snapshot_win, info->id, DBOX_STATUS_ERROR_FAULT, info->data);
+	}
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    if (flush_cb) {
+	int w;
+	int h;
+	int ret;
+
+	ecore_evas_geometry_get(ee, NULL, NULL, &w, &h);
+
+	DbgPrint("Flush size: %dx%d\n", w, h);
+	ret = flush_to_file(canvas, info->id, w, h);
+	if (status == DBOX_STATUS_ERROR_NONE) {
+	    status = ret;
+	}
+
+	flush_cb(snapshot_win, info->id, status, info->data);
+	/**
+	 * Do not access info after this.
+	 */
+    }
+
+    return ECORE_CALLBACK_CANCEL;
+}
+
+static void del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+    struct snapshot_info *info;
+
+    info = evas_object_data_del(obj, "snapshot,info");
+    if (!info) {
+	return;
+    }
+
+    DbgPrint("Delete object (%s)\n", info->id);
+
+    evas_event_callback_del(e, EVAS_CALLBACK_RENDER_POST, post_render_cb);
+    evas_event_callback_del(e, EVAS_CALLBACK_RENDER_PRE, pre_render_cb);
+
+    if (info->flush_timer) {
+	ecore_timer_del(info->flush_timer);
+	info->flush_timer = NULL;
+
+	(void)snapshot_cb(obj);
+	DbgPrint("Flush is canceled\n");
+    }
+
+    /**
+     * @note
+     * Render callback will be deleted.
+     */
+    free(info->id);
+    free(info);
+}
+
+static Eina_Bool direct_snapshot_cb(void *data)
+{
+    Evas *e;
+    Ecore_Evas *ee;
+    const void *canvas;
+    int status;
+    int w;
+    int h;
+    dynamicbox_flush_cb flush_cb;
+    Evas_Object *snapshot_win = data;
+    struct snapshot_info *info;
+
+    info = evas_object_data_get(snapshot_win, "snapshot,info");
+    if (!info) {
+	ErrPrint("Unable to get snapshot info\n");
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    info->flush_timer = NULL;
+    flush_cb = info->flush_cb;
+    info->flush_cb = NULL; /* To prevent call this from the delete callback */
+
+    e = evas_object_evas_get(snapshot_win);
+    if (!e) {
+	ErrPrint("Invalid object, failed to get Evas\n");
+	if (flush_cb) {
+	    flush_cb(snapshot_win, info->id, DBOX_STATUS_ERROR_FAULT, info->data);
+	}
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    ee = ecore_evas_ecore_evas_get(e);
+    if (!ee) {
+	ErrPrint("Unable to get Ecore_Evas object\n");
+	if (flush_cb) {
+	    flush_cb(snapshot_win, info->id, DBOX_STATUS_ERROR_FAULT, info->data);
+	}
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    ecore_evas_geometry_get(ee, NULL, NULL, &w, &h);
+    ecore_evas_manual_render_set(ee, EINA_TRUE);
+
+    canvas = ecore_evas_buffer_pixels_get(ee);
+    if (!canvas) {
+	ErrPrint("Failed to get canvas\n");
+	if (flush_cb) {
+	    flush_cb(snapshot_win, info->id, DBOX_STATUS_ERROR_FAULT, info->data);
+	}
+	return ECORE_CALLBACK_CANCEL;
+    }
+
+    status = flush_to_file(canvas, info->id, w, h);
+    if (flush_cb) {
+	flush_cb(snapshot_win, info->id, status, info->data);
+    }
+    return ECORE_CALLBACK_CANCEL;
+}
+
+static void post_render_cb(void *data, Evas *e, void *event_info)
+{
+    Evas_Object *snapshot_win = data;
+    struct snapshot_info *info;
+
+    info = evas_object_data_get(snapshot_win, "snapshot,info");
+    if (!info) {
+	ErrPrint("snapshot info is not valid\n");
+	return;
+    }
+
+    info->render_cnt++;
+
+    if (info->flush_timer) {
+	/**
+	 * @note
+	 * This has not to be happens.
+	 */
+	ErrPrint("Flush timer is not cleared\n");
+	ecore_timer_del(info->flush_timer);
+	info->flush_timer = NULL;
+    }
+
+    if (!info->flush_cb) {
+	DbgPrint("Flush request is not initiated yet\n");
+	return;
+    }
+
+    /*!
+     * \NOTE
+     * Even if tehre is no timer registered, we should capture the content
+     * from out of this callback.
+     * Or we can met unexpected problems.
+     * To avoid it, use the 0.0001f to get timer callback ASAP, not in this function.
+     */
+    DbgPrint("Fire the flush timer %lf (%d)\n", info->timeout, info->render_cnt);
+    info->flush_timer = ecore_timer_add(info->timeout, snapshot_cb, snapshot_win);
+    if (!info->flush_timer) {
+	dynamicbox_flush_cb flush_cb;
+
+	ErrPrint("Unalbe to add timer for getting the snapshot\n");
+	flush_cb = info->flush_cb;
+	info->flush_cb = NULL;
+
+	if (flush_cb) {
+	    flush_cb(snapshot_win, info->id, DBOX_STATUS_ERROR_FAULT, info->data);
+	}
+	/*!
+	 * \note
+	 * Do not access info after from here.
+	 */
+    }
+}
+
+static void pre_render_cb(void *data, Evas *e, void *event_info)
+{
+    Evas_Object *snapshot_win = data;
+    struct snapshot_info *info;
+
+    info = evas_object_data_get(snapshot_win, "snapshot,info");
+    if (!info) {
+	ErrPrint("snapshot info is not valid\n");
+	return;
+    }
+
+    if (info->flush_timer) {
+	ecore_timer_del(info->flush_timer);
+	info->flush_timer = NULL;
+	DbgPrint("Clear the flush timer\n");
+    }
+
+    DbgPrint("Pre-render callback\n");
+}
+
+PUBLIC void *dynamicbox_snapshot_window_add(const char *id, int size_type)
+{
+    struct snapshot_info *info;
+    Evas_Object *snapshot_win;
+    Evas_Object *parent;
+    Evas *e;
+    int w;
+    int h;
+
+    if (dynamicbox_service_get_size(size_type, &w, &h) != DBOX_STATUS_ERROR_NONE) {
+	ErrPrint("Invalid size\n");
+	return NULL;
+    }
+
+    info = malloc(sizeof(*info));
+    if (!info) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return NULL;
+    }
+
+    info->id = strdup(id);
+    if (!info->id) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	free(info);
+	return NULL;
+    }
+
+    info->flush_cb = NULL;
+    info->data = NULL;
+    info->flush_timer = NULL;
+    info->render_cnt = 0;
+
+    e = create_virtual_canvas(w, h);
+    if (!e) {
+	free(info->id);
+	free(info);
+	return NULL;
+    }
+
+    parent = evas_object_rectangle_add(e);
+    if (!parent) {
+	destroy_virtual_canvas(e);
+	free(info->id);
+	free(info);
+	return NULL;
+    }
+
+    snapshot_win = elm_win_add(parent, "DBox,Snapshot", ELM_WIN_DYNAMIC_BOX);
+    evas_object_del(parent);
+    if (!snapshot_win) {
+	destroy_virtual_canvas(e);
+	free(info->id);
+	free(info);
+	return NULL;
+    }
+
+    DbgPrint("Create a new window %dx%d for %s\n", w, h, id);
+    evas_object_event_callback_add(snapshot_win, EVAS_CALLBACK_DEL, del_cb, NULL);
+    evas_object_resize(snapshot_win, w, h);
+    evas_object_show(snapshot_win);
+
+    evas_object_data_set(snapshot_win, "snapshot,info", info);
+
+    evas_event_callback_add(e, EVAS_CALLBACK_RENDER_POST, post_render_cb, snapshot_win);
+    evas_event_callback_add(e, EVAS_CALLBACK_RENDER_PRE, pre_render_cb, snapshot_win);
+
+    return snapshot_win;
+}
+
+PUBLIC int dynamicbox_snapshot_window_flush(void *snapshot_win, double timeout, dynamicbox_flush_cb flush_cb, void *data)
+{
+    struct snapshot_info *info;
+
+    if (!flush_cb || timeout < 0.0f) {
+	ErrPrint("Invalid argument (%p, %lf)\n", flush_cb, timeout);
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    info = evas_object_data_get(snapshot_win, "snapshot,info");
+    if (!info) {
+	ErrPrint("Invalid argument\n");
+	return DBOX_STATUS_ERROR_INVALID_PARAMETER;
+    }
+
+    info->timeout = timeout;
+
+    if (timeout == 0.0f) {
+	/*!
+	 * This timer is just used for guarantees same behavious even if it flushes content directly,
+	 * The callback should be called from next loop.
+	 * or the developer will get confused
+	 */
+	info->flush_timer = ecore_timer_add(0.0001f, direct_snapshot_cb, snapshot_win);
+	if (!info->flush_timer) {
+	    return DBOX_STATUS_ERROR_FAULT;
+	}
+    } else if (info->render_cnt) {
+	/*!
+	 * Try to watit pre-render callback.
+	 * If there is rendered contents.
+	 */
+	DbgPrint("Rendered %d times already\n", info->render_cnt);
+	info->flush_timer = ecore_timer_add(info->timeout, snapshot_cb, snapshot_win);
+	if (!info->flush_timer) {
+	    return DBOX_STATUS_ERROR_FAULT;
+	}
+    }
+
+    info->flush_cb = flush_cb;
+    info->data = data;
+
+    return DBOX_STATUS_ERROR_NONE;
+}
+
+/* End of a file */
diff --git a/dynamicbox/src/util.c b/dynamicbox/src/util.c
new file mode 100644
index 0000000..e9f5ebe
--- /dev/null
+++ b/dynamicbox/src/util.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2013  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/time.h>
+
+#include <Ecore.h>
+#include <dlog.h>
+
+#include "debug.h"
+#include "util.h"
+
+int errno;
+
+int util_check_extension(const char *filename, const char *check_ptr)
+{
+    int name_len;
+
+    name_len = strlen(filename);
+    while (--name_len >= 0 && *check_ptr) {
+	if (filename[name_len] != *check_ptr)
+	    return -EINVAL;
+
+	check_ptr ++;
+    }
+
+    return 0;
+}
+
+double util_timestamp(void)
+{
+#if defined(_USE_ECORE_TIME_GET)
+    return ecore_time_get();
+#else
+    struct timeval tv;
+
+    gettimeofday(&tv, NULL);
+
+    return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0f;
+#endif
+}
+
+/* End of a file */
diff --git a/dynamicbox/src/virtual_window.c b/dynamicbox/src/virtual_window.c
new file mode 100644
index 0000000..e396df6
--- /dev/null
+++ b/dynamicbox/src/virtual_window.c
@@ -0,0 +1,1014 @@
+/*
+ * Copyright 2013  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _GNU_SOURCE
+
+#include <Elementary.h>
+#include <string.h>
+#include <Ecore_Evas.h>
+#include <Ecore_X.h>
+#include <Evas.h>
+#include <dlfcn.h>
+#include <Eina.h>
+
+#include <X11/Xlib.h>
+
+#include <dlog.h>
+#include <dynamicbox_errno.h>
+#include <dynamicbox_service.h>
+#include <dynamicbox_conf.h>
+#include <dynamicbox_buffer.h>
+
+#include "dynamicbox.h"
+#include "internal/dynamicbox.h"
+#include "debug.h"
+
+#define IS_GBAR 1
+
+#define PUBLIC __attribute__((visibility("default")))
+#define DBOX_WIN_TAG "dynamic,box,win"
+
+#define DBOX_DEFAULT_WIDTH 1
+#define DBOX_DEFAULT_HEIGHT 1
+#define GL_ENGINE "opengl_x11"
+
+static struct static_info {
+    Ecore_Evas *(*alloc_canvas)(int w, int h, void *(*a)(void *data, int size), void (*f)(void *data, void *ptr), void *data);
+    Ecore_Evas *(*alloc_canvas_with_stride)(int w, int h, void *(*a)(void *data, int size, int *stride, int *bpp), void (*f)(void *data, void *ptr), void *data);
+    Ecore_Evas *(*alloc_canvas_with_pixmap)(const char *disp_name, Ecore_X_Window parent, int x, int y, int w, int h, Ecore_X_Pixmap (*alloc_cb)(void *data, Ecore_X_Window parent, int w, int h, int depth), void (*free_cb)(void *data, Ecore_X_Pixmap pixmap), void *data);
+} s_info = {
+    .alloc_canvas = NULL,
+    .alloc_canvas_with_stride = NULL,
+    .alloc_canvas_with_pixmap = NULL,
+};
+
+/**
+ * @brief
+ * Abstracted Data Type of Virtual Window
+ */
+typedef struct virtual_window_info {
+    char *id; /**< Identification */
+    dynamicbox_buffer_h handle; /**< Livebox buffer handle */
+    enum win_type {
+	VWIN_SW_BUF = 0x00, /**< S/W buffer */
+	VWIN_GEM    = 0x01, /**< GEM buffer */
+	VWIN_PIXMAP = 0x02, /**< PIXMAP */
+	VWIN_ERROR  = 0x03  /**< Unknown */
+    } type;
+    Ecore_Evas *ee;
+    Evas *e;
+    int is_gbar;
+    int deleted;
+    int w;
+    int h;
+    unsigned int *resource_array;
+    int resource_cnt;
+
+    int pressed;
+} *vwin_info_t;
+
+static inline Evas_Object *get_highlighted_object(Evas_Object *obj)
+{
+    Evas_Object *o, *ho;
+
+    o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
+    if (!o) return NULL;
+
+    ho = evas_object_data_get(o, "_elm_access_target");
+    return ho;
+}
+
+/**
+ * @note
+ * Every user event (mouse) on the buffer will be passed via this event callback
+ */
+static int event_handler_cb(dynamicbox_buffer_h handler, struct dynamicbox_buffer_event_data *event_info, void *data)
+{
+    vwin_info_t info = data;
+    Elm_Access_Action_Info action_info;
+    Elm_Access_Action_Type action_type;
+    int ret = 0;
+    Evas_Object *parent_elm;
+    KeySym *key_symbol;
+    unsigned int flags = 0;
+    double timestamp;
+
+    if (!info->handle) {
+	/* Just ignore this event */
+	return 0;
+    }
+
+    if (DYNAMICBOX_CONF_USE_GETTIMEOFDAY) {
+	if (DYNAMICBOX_CONF_EVENT_FILTER > 0.0f && (info->pressed == 0 || event_info->type == DBOX_BUFFER_EVENT_MOVE)) {
+	    struct timeval tv;
+
+	    if (gettimeofday(&tv, NULL) < 0) {
+		ErrPrint("gettimeofday: %s\n", strerror(errno));
+	    } else {
+		timestamp = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0f;
+		timestamp -= event_info->timestamp;
+
+		if (timestamp > DYNAMICBOX_CONF_EVENT_FILTER) {
+		    DbgPrint("Dropped %lf\n", timestamp);
+		    return 0;
+		}
+	    }
+	}
+
+	/**
+	 * If the device doesn't use the clock monotic time, we have to emulate it for EVAS
+	 * Evas only use the monotic time for animating objects
+	 */
+	timestamp = ecore_time_get() * 1000.0f;
+    } else {
+	if (DYNAMICBOX_CONF_EVENT_FILTER > 0.0f && (info->pressed == 0 || event_info->type == DBOX_BUFFER_EVENT_MOVE)) {
+	    timestamp = ecore_time_get();
+
+	    timestamp -= event_info->timestamp;
+	    if (timestamp > DYNAMICBOX_CONF_EVENT_FILTER) {
+		DbgPrint("Dropped %lf\n", timestamp);
+		return 0;
+	    }
+	}
+
+	timestamp = event_info->timestamp * 1000.0f;
+    }
+
+    /**
+     * @note
+     * Feed up events
+     */
+    switch (event_info->type) {
+    case DBOX_BUFFER_EVENT_ON_HOLD:
+	flags = evas_event_default_flags_get(info->e);
+	flags |= EVAS_EVENT_FLAG_ON_HOLD;
+	evas_event_default_flags_set(info->e, flags);
+	ErrPrint("ON_HOLD[%s] %dx%d - %lf\n", info->id, event_info->info.pointer.x, event_info->info.pointer.y, timestamp);
+	break;
+    case DBOX_BUFFER_EVENT_OFF_HOLD:
+	flags = evas_event_default_flags_get(info->e);
+	flags &= ~EVAS_EVENT_FLAG_ON_HOLD;
+	evas_event_default_flags_set(info->e, flags);
+	break;
+    case DBOX_BUFFER_EVENT_ON_SCROLL:
+	flags = evas_event_default_flags_get(info->e);
+	flags |= EVAS_EVENT_FLAG_ON_SCROLL;
+	evas_event_default_flags_set(info->e, flags);
+	break;
+    case DBOX_BUFFER_EVENT_OFF_SCROLL:
+	flags = evas_event_default_flags_get(info->e);
+	flags &= ~EVAS_EVENT_FLAG_ON_SCROLL;
+	evas_event_default_flags_set(info->e, flags);
+	break;
+    case DBOX_BUFFER_EVENT_ENTER:
+	evas_event_feed_mouse_in(info->e, timestamp, NULL);
+	break;
+    case DBOX_BUFFER_EVENT_LEAVE:
+	evas_event_feed_mouse_out(info->e, timestamp, NULL);
+	break;
+    case DBOX_BUFFER_EVENT_DOWN:
+	if (info->pressed) {
+	    ErrPrint("MOUSE UP is not called\n");
+	    ErrPrint("UP[%s] %dx%d - %lf\n", info->id, event_info->info.pointer.x, event_info->info.pointer.y, timestamp);
+	    evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, timestamp, NULL);
+	    evas_event_feed_mouse_up(info->e, 1, EVAS_BUTTON_NONE, timestamp, NULL);
+	}
+
+	/**
+	 * @note
+	 * Before processing the DOWN event,
+	 * Reset the evas event flags regarding ON_HOLD option.
+	 * It can be re-enabled while processing down-move-up events.
+	 */
+	flags = evas_event_default_flags_get(info->e);
+	flags &= ~EVAS_EVENT_FLAG_ON_SCROLL;
+	flags &= ~EVAS_EVENT_FLAG_ON_HOLD;
+	evas_event_default_flags_set(info->e, flags);
+	/**
+	 * @note
+	 * Calculate the event occurred X & Y on the buffer
+	 */
+	evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, timestamp, NULL);
+	evas_event_feed_mouse_down(info->e, 1, EVAS_BUTTON_NONE, timestamp, NULL); /* + 0.2f just for fake event */
+	info->pressed = 1;
+	ErrPrint("DOWN[%s] %dx%d - %lf\n", info->id, event_info->info.pointer.x, event_info->info.pointer.y, timestamp);
+	break;
+    case DBOX_BUFFER_EVENT_MOVE:
+	/**
+	 * @note
+	 * Calculate the event occurred X & Y on the buffer
+	 */
+	evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, timestamp, NULL);
+	break;
+    case DBOX_BUFFER_EVENT_UP:
+	evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, timestamp, NULL);
+	evas_event_feed_mouse_up(info->e, 1, EVAS_BUTTON_NONE, timestamp, NULL);
+	info->pressed = 0;
+	/**
+	 * @note
+	 * We have to keep the event flags, so we should not clear them from here.
+	 * Sometimes, asynchronously callable Callbacks can refer the evas event flags after up event.
+	 * so if we reset them from here, those kind of callbacks will fails to do their job properly.
+	 */
+	ErrPrint("UP[%s] %dx%d - %lf\n", info->id, event_info->info.pointer.x, event_info->info.pointer.y, timestamp);
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_HIGHLIGHT;
+	/**
+	 * @note
+	 * Calculate the event occurred X & Y on the buffer
+	 */
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	if (ret == EINA_TRUE) {
+	    if (!get_highlighted_object(parent_elm)) {
+		ErrPrint("Highlighted object is not found\n");
+		ret = DBOX_ACCESS_STATUS_ERROR;
+	    } else {
+		DbgPrint("Highlighted object is found\n");
+		ret = DBOX_ACCESS_STATUS_DONE;
+	    }
+	} else {
+	    ErrPrint("Action error\n");
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	}
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_NEXT:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
+	action_info.highlight_cycle = EINA_FALSE;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_LAST : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_PREV:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
+	action_info.highlight_cycle = EINA_FALSE;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_FIRST : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_ACTIVATE:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_ACTIVATE;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_ACTION_UP:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_UP;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_ACTION_DOWN:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_DOWN;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_SCROLL_UP:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_SCROLL;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_SCROLL_MOVE:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_SCROLL;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_SCROLL_DOWN:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_SCROLL;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_UNHIGHLIGHT:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_UNHIGHLIGHT;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_VALUE_CHANGE:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_VALUE_CHANGE;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_MOUSE:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_MOUSE;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_BACK:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_BACK;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_OVER:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_OVER;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_READ:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_READ;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_ENABLE:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_ENABLE;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_ACCESS_DISABLE:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+	memset(&action_info, 0, sizeof(action_info));
+	action_type = ELM_ACCESS_ACTION_DISABLE;
+	action_info.x = event_info->info.access.x;
+	action_info.y = event_info->info.access.y;
+	action_info.mouse_type = event_info->info.access.mouse_type;
+	ret = elm_access_action(parent_elm, action_type, &action_info);
+	ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	break;
+    case DBOX_BUFFER_EVENT_KEY_DOWN:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+
+	key_symbol = XGetKeyboardMapping(ecore_x_display_get(), event_info->info.keycode, 1, &ret);
+	if (key_symbol) {
+	    char *key_name;
+	    char *key_string;
+
+	    key_string = XKeysymToString(*key_symbol);
+	    key_name = XKeysymToString(*key_symbol);
+	    DbgPrint("Key symbol: %s, name: %s\n", key_string, key_name);
+	    XFree(key_symbol);
+	    XFree(key_name);
+	    XFree(key_string);
+	}
+	ret = DBOX_KEY_STATUS_ERROR;
+	break;
+    case DBOX_BUFFER_EVENT_KEY_UP:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+
+	key_symbol = XGetKeyboardMapping(ecore_x_display_get(), event_info->info.keycode, 1, &ret);
+	if (key_symbol) {
+	    char *key_name;
+	    char *key_string;
+
+	    key_string = XKeysymToString(*key_symbol);
+	    key_name = XKeysymToString(*key_symbol);
+	    DbgPrint("Key symbol: %s, name: %s\n", key_string, key_name);
+	    XFree(key_symbol);
+	    XFree(key_name);
+	    XFree(key_string);
+	}
+	ret = DBOX_KEY_STATUS_ERROR;
+	break;
+    case DBOX_BUFFER_EVENT_KEY_FOCUS_IN:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+
+	key_symbol = XGetKeyboardMapping(ecore_x_display_get(), event_info->info.keycode, 1, &ret);
+	if (key_symbol) {
+	    char *key_name;
+	    char *key_string;
+
+	    key_string = XKeysymToString(*key_symbol);
+	    key_name = XKeysymToString(*key_symbol);
+	    DbgPrint("Key symbol: %s, name: %s\n", key_string, key_name);
+	    XFree(key_symbol);
+	    XFree(key_name);
+	    XFree(key_string);
+	}
+	ret = DBOX_KEY_STATUS_ERROR;
+	break;
+    case DBOX_BUFFER_EVENT_KEY_FOCUS_OUT:
+	parent_elm = ecore_evas_data_get(info->ee, DBOX_WIN_TAG);
+	if (!parent_elm) {
+	    ret = DBOX_ACCESS_STATUS_ERROR;
+	    break;
+	}
+
+	key_symbol = XGetKeyboardMapping(ecore_x_display_get(), event_info->info.keycode, 1, &ret);
+	if (key_symbol) {
+	    char *key_name;
+	    char *key_string;
+
+	    key_string = XKeysymToString(*key_symbol);
+	    key_name = XKeysymToString(*key_symbol);
+	    DbgPrint("Key symbol: %s, name: %s\n", key_string, key_name);
+	    XFree(key_symbol);
+	    XFree(key_name);
+	    XFree(key_string);
+	}
+	ret = DBOX_KEY_STATUS_ERROR;
+	break;
+    default:
+	DbgPrint("Unhandled buffer event (%d)\n", event_info->type);
+	break;
+    }
+
+    return ret;
+}
+
+/**
+ * @note
+ * This callback can be called twice (or more) to get a several pixmaps
+ * Acquired pixmaps are used for double/tripple buffering for canvas
+ */
+static Ecore_X_Pixmap alloc_pixmap_cb(void *data, Ecore_X_Window parent, int w, int h, int depth)
+{
+    vwin_info_t info = data;
+    Ecore_X_Pixmap pixmap;
+
+    if (!info->handle) {
+	ErrPrint("Invalid handle\n");
+	return 0u;
+    }
+
+    info->w = w;
+    info->h = h;
+    DbgPrint("Size of ee is updated: %dx%d - %d (info: %p)\n", info->w, info->h, depth, info);
+    depth >>= 3;
+
+    if (dynamicbox_resource_id(info->handle, DBOX_PRIMARY_BUFFER) == 0u) {
+	/**
+	 * @note
+	 * Need to allocate a primary buffer
+	 */
+	dynamicbox_acquire_buffer(info->handle, DBOX_PRIMARY_BUFFER, info->w, info->h, depth);
+	if (!info->handle) {
+	    ErrPrint("Failed to get the buffer\n");
+	    return 0u;
+	}
+
+	pixmap = (Ecore_X_Pixmap)dynamicbox_resource_id(info->handle, DBOX_PRIMARY_BUFFER);
+    } else if (DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT > 0) {
+	int idx;
+
+	if (!info->resource_array) {
+	    info->resource_array = calloc(DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT, sizeof(*info->resource_array));
+	    if (!info->resource_array) {
+		ErrPrint("Out of memory: %s\n", strerror(errno));
+		return 0u;
+	    }
+
+	    idx = 0;
+	} else {
+	    for (idx = 0; idx < DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT; idx++) {
+		if (info->resource_array[idx] == 0u) {
+		    break;
+		}
+	    }
+
+	    if (idx == DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT) {
+		ErrPrint("Out of index: %d\n", idx);
+		return 0u;
+	    }
+	}
+
+	if (dynamicbox_acquire_buffer(info->handle, idx, info->w, info->h, depth) < 0) {
+	    ErrPrint("Failed to acquire a buffer for %d\n", idx);
+	    return 0u;
+	}
+
+	info->resource_array[idx] = dynamicbox_resource_id(info->handle, idx);
+	if (info->resource_array[idx] == 0u) {
+	    ErrPrint("Failed to allocate pixmap\n");
+	}
+
+	DbgPrint("Allocated index: %d/%d - %u\n", idx, DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT, info->resource_array[idx]);
+	pixmap = info->resource_array[idx];
+    } else {
+	ErrPrint("Unable to allocate pixmap\n");
+	pixmap = 0u;
+    }
+
+    /**
+     * Acquire a buffer for canvas.
+     */
+    info->type = VWIN_PIXMAP;
+    info->resource_cnt += !!(unsigned int)pixmap;
+    return pixmap;
+}
+
+static void free_pixmap_cb(void *data, Ecore_X_Pixmap pixmap)
+{
+    vwin_info_t info = data;
+
+    if (!info->handle) {
+	return;
+    }
+
+    if (info->type != VWIN_PIXMAP) {
+	ErrPrint("Impossible\n");
+    }
+
+    if (dynamicbox_resource_id(info->handle, DBOX_PRIMARY_BUFFER) == pixmap) {
+	if (dynamicbox_release_buffer(info->handle, DBOX_PRIMARY_BUFFER) < 0) {
+	    DbgPrint("Failed to release buffer\n");
+	}
+	info->resource_cnt--;
+    } else {
+	int idx;
+
+	for (idx = 0; idx < DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT; idx++) {
+	    /**
+	     * @note
+	     * Find a index to release it
+	     */
+	    if (info->resource_array[idx] == pixmap) {
+		if (dynamicbox_release_buffer(info->handle, idx) < 0) {
+		    DbgPrint("Failed to release buffer\n");
+		}
+		info->resource_array[idx] = 0u;
+		info->resource_cnt--;
+		break;
+	    }
+	}
+    }
+
+    if (info->deleted && info->resource_cnt == 0) {
+	DbgPrint("Destroy buffer handle\n");
+
+	dynamicbox_destroy_buffer(info->handle);
+	free(info->resource_array);
+	free(info->id);
+	free(info);
+    }
+}
+
+static void *alloc_fb(void *data, int size)
+{
+    vwin_info_t info = data;
+    void *buffer;
+
+    if (info->ee) {
+	ecore_evas_geometry_get(info->ee, NULL, NULL, &info->w, &info->h);
+	DbgPrint("Size of ee is updated: %dx%d (info: %p)\n", info->w, info->h, info);
+    }
+
+    if (!info->handle) {
+	ErrPrint("Failed to create a buffer\n");
+	return NULL;
+    }
+
+    if (dynamicbox_acquire_buffer(info->handle, DBOX_PRIMARY_BUFFER, info->w, info->h, sizeof(int)) < 0) {
+	ErrPrint("Failed to acquire buffer\n");
+	return NULL;
+    }
+
+    /**
+     * If it supports the H/W accelerated buffer,
+     * Use it.
+     */
+    if (dynamicbox_support_hw_buffer(info->handle)) {
+	if (dynamicbox_create_hw_buffer(info->handle) == 0) {
+	    buffer = dynamicbox_buffer_hw_buffer(info->handle);
+	    if (buffer) {
+		DbgPrint("HW Accelerated buffer is created %p, (%dx%d)\n", info, info->w, info->h);
+		info->type = VWIN_GEM;
+		return buffer;
+	    }
+	}
+
+	ErrPrint("Failed to allocate HW Accelerated buffer\n");
+    }
+
+    /**
+     * Or use the buffer of a S/W backend.
+     */
+    buffer = dynamicbox_ref_buffer(info->handle);
+    DbgPrint("SW buffer is created (%dx%d)\n", info->w, info->h);
+    info->type = VWIN_SW_BUF;
+    return buffer;
+}
+
+static void *alloc_stride_fb(void *data, int size, int *stride, int *bpp)
+{
+    void *buffer;
+
+    buffer = alloc_fb(data, size);
+    if (buffer) {
+	vwin_info_t info = data;
+	int _stride;
+
+	*bpp = sizeof(int);
+	_stride = dynamicbox_buffer_stride(info->handle);
+	if (_stride < 0) {
+	    _stride = info->w * *bpp;
+	}
+
+	*stride = _stride;
+	*bpp <<= 3;
+	DbgPrint("bpp: %d, stride: %d\n", *bpp, *stride);
+    }
+
+    return buffer;
+}
+
+static void free_fb(void *data, void *ptr)
+{
+    vwin_info_t info = data;
+
+    if (!info->handle) {
+	return;
+    }
+
+    if (info->type == VWIN_GEM) {
+	if (dynamicbox_destroy_hw_buffer(info->handle) == 0) {
+	    DbgPrint("HW Accelerated buffer is destroyed\n");
+	}
+    } else if (info->type == VWIN_SW_BUF) {
+	DbgPrint("SW buffer is destroyed, %p\n", info);
+	dynamicbox_unref_buffer(ptr);
+    } else if (info->type == VWIN_PIXMAP) {
+	ErrPrint("Unable to reach to here\n");
+    }
+
+    if (dynamicbox_release_buffer(info->handle, DBOX_PRIMARY_BUFFER) < 0) {
+	ErrPrint("Failed to release buffer\n");
+    }
+
+    if (info->deleted) {
+	dynamicbox_destroy_buffer(info->handle);
+	free(info->resource_array);
+	free(info->id);
+	free(info);
+    }
+}
+
+static void pre_render_cb(void *data, Evas *e, void *event_info)
+{
+    vwin_info_t info = data;
+
+    if (!info->handle) {
+	return;
+    }
+
+    if (dynamicbox_conf_premultiplied_alpha()) {
+	Evas_Coord w;
+	Evas_Coord h;
+
+	ecore_evas_geometry_get(info->ee, NULL, NULL, &w, &h);
+	evas_damage_rectangle_add(e, 0, 0, w, h);
+    }
+
+    if (info->type == VWIN_GEM) {
+	dynamicbox_buffer_pre_render(info->handle);
+    } else if (info->type == VWIN_PIXMAP) {
+	/**
+	 * Only the pixmap type Ecore_Evas uses this variable
+	 */
+    } else if (info->type == VWIN_SW_BUF) {
+	/* Do nothing */
+    }
+}
+
+static void post_render_cb(void *data, Evas *e, void *event_info)
+{
+    vwin_info_t info = data;
+
+    if (!info->handle) {
+	return;
+    }
+
+    if (dynamicbox_conf_premultiplied_alpha()) {
+	void *canvas;
+	int x, y, w, h;
+
+	// Get a pointer of a buffer of the virtual canvas
+	canvas = (void *)ecore_evas_buffer_pixels_get(info->ee);
+	if (!canvas) {
+	    ErrPrint("Failed to get pixel canvas\n");
+	    return;
+	}
+
+	ecore_evas_geometry_get(info->ee, &x, &y, &w, &h);
+	evas_data_argb_unpremul(canvas, w * h);
+    }
+
+    if (info->type == VWIN_GEM) {
+	dynamicbox_buffer_post_render(info->handle);
+    } else if (info->type == VWIN_PIXMAP) {
+	int idx;
+	unsigned int front_resource_id;
+
+	front_resource_id = ecore_evas_gl_x11_pixmap_get(info->ee);
+
+	for (idx = 0; idx < DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT; idx++) {
+	    if (front_resource_id == info->resource_array[idx]) {
+		/**
+		 */
+		dynamicbox_send_updated_by_idx(info->handle, idx);
+		break;
+	    }
+	}
+
+	if (idx == DYNAMICBOX_CONF_EXTRA_BUFFER_COUNT) {
+	    /* Send updated event for PRIMARY BUFFER */
+	    if (front_resource_id == dynamicbox_resource_id(info->handle, DBOX_PRIMARY_BUFFER)) {
+		dynamicbox_send_updated_by_idx(info->handle, DBOX_PRIMARY_BUFFER);
+	    } else {
+		DbgPrint("Unable to send updated: %u (%u)\n", front_resource_id, dynamicbox_resource_id(info->handle, DBOX_PRIMARY_BUFFER));
+	    }
+	}
+    } else if (info->type == VWIN_SW_BUF) {
+	dynamicbox_sync_buffer(info->handle);
+    }
+}
+
+static void ecore_evas_free_cb(Ecore_Evas *ee)
+{
+    vwin_info_t info;
+
+    info = ecore_evas_data_get(ee, "dynamic,box,info");
+    if (!info) {
+	DbgPrint("Info is not valid\n");
+	return;
+    }
+
+    if (info->e) {
+	evas_event_callback_del(info->e, EVAS_CALLBACK_RENDER_POST, post_render_cb);
+	evas_event_callback_del(info->e, EVAS_CALLBACK_RENDER_PRE, pre_render_cb);
+    }
+
+    info->deleted = 1;
+    info->ee = NULL;
+}
+
+PUBLIC void *dynamicbox_get_evas_object(const char *id, int is_gbar)
+{
+    vwin_info_t info;
+    Evas_Object *rect;
+    const char *engine;
+
+    if (!s_info.alloc_canvas && !s_info.alloc_canvas_with_stride && !s_info.alloc_canvas_with_pixmap) {
+	s_info.alloc_canvas_with_pixmap = dlsym(RTLD_DEFAULT, "ecore_evas_gl_x11_pixmap_allocfunc_new");
+	if (!s_info.alloc_canvas_with_pixmap) {
+	    DbgPrint("pixmap_allocfunc_new is not found\n");
+	}
+
+	s_info.alloc_canvas_with_stride = dlsym(RTLD_DEFAULT, "ecore_evas_buffer_allocfunc_with_stride_new");
+	if (!s_info.alloc_canvas_with_stride) {
+	    DbgPrint("allocfunc_with_stirde_new is not found\n");
+	}
+
+	s_info.alloc_canvas = dlsym(RTLD_DEFAULT, "ecore_evas_buffer_allocfunc_new");
+	if (!s_info.alloc_canvas) {
+	    ErrPrint("allocfunc_new is not found\n");
+	}
+
+	if (!s_info.alloc_canvas_with_stride && !s_info.alloc_canvas && !s_info.alloc_canvas_with_pixmap) {
+	    ErrPrint("No way to allocate canvas\n");
+	    return NULL;
+	}
+    }
+
+    if (!id) {
+	ErrPrint("Invalid parameter\n");
+	return NULL;
+    }
+
+    info = calloc(1, sizeof(*info));
+    if (!info) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return NULL;
+    }
+
+    info->id = strdup(id);
+    if (!info->id) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	free(info);
+	return NULL;
+    }
+
+    info->is_gbar = is_gbar;
+
+    /**
+     * Acquire a buffer for canvas.
+     */
+    info->handle = dynamicbox_create_buffer(info->id, info->is_gbar,
+	    (dynamicbox_conf_auto_align() || !s_info.alloc_canvas_with_stride),
+	    event_handler_cb, info);
+
+    if (!info->handle) {
+	ErrPrint("Failed to create a dynamicbox buffer\n");
+	free(info->id);
+	free(info);
+	return NULL;
+    }
+
+    /**
+     * Size information must be initialized before call the ecore_evas_buffer_new.
+     */
+    info->w = DBOX_DEFAULT_WIDTH;
+    info->h = DBOX_DEFAULT_HEIGHT;
+
+    engine = elm_config_preferred_engine_get();
+    DbgPrint("Preferred engine: %s (%s)\n", engine, GL_ENGINE);
+    if (engine && !strcmp(engine, GL_ENGINE)) {
+	if (s_info.alloc_canvas_with_pixmap) {
+	    info->ee = s_info.alloc_canvas_with_pixmap(NULL, 0u, 0, 0, info->w, info->h, alloc_pixmap_cb, free_pixmap_cb, info);
+	    if (!info->ee) {
+		ErrPrint("Unable to create a ee for pixmap\n");
+	    }
+	}
+    }
+
+    if (!info->ee) {
+	if (!dynamicbox_conf_auto_align() && s_info.alloc_canvas_with_stride) {
+	    info->ee = s_info.alloc_canvas_with_stride(info->w, info->h, alloc_stride_fb, free_fb, info);
+	} else if (s_info.alloc_canvas) {
+	    info->ee = s_info.alloc_canvas(info->w, info->h, alloc_fb, free_fb, info);
+	}
+    }
+
+    if (!info->ee) {
+	ErrPrint("Failed to create ecore_evas (%dx%d)\n", info->w, info->h);
+	dynamicbox_destroy_buffer(info->handle);
+	free(info->id);
+	free(info);
+	return NULL;
+    }
+
+    ecore_evas_data_set(info->ee, "dynamic,box,info", info);
+
+    /**
+     * @note
+     * Free callback must be prepared before use the ecore_evas_free()
+     */
+    ecore_evas_callback_pre_free_set(info->ee, ecore_evas_free_cb);
+
+    info->e = ecore_evas_get(info->ee);
+    if (!info->e) {
+	ErrPrint("Failed to get evas\n");
+	ecore_evas_free(info->ee);
+	return NULL;
+    }
+
+    pre_render_cb(info, NULL, NULL);
+    ecore_evas_alpha_set(info->ee, EINA_TRUE);
+    post_render_cb(info, NULL, NULL);
+
+    ecore_evas_manual_render_set(info->ee, EINA_FALSE);
+    ecore_evas_resize(info->ee, info->w, info->h);
+
+    evas_event_callback_add(info->e, EVAS_CALLBACK_RENDER_POST, post_render_cb, info);
+    evas_event_callback_add(info->e, EVAS_CALLBACK_RENDER_PRE, pre_render_cb, info);
+
+    rect = evas_object_rectangle_add(info->e);
+    if (!rect) {
+	ErrPrint("Failed to create evas_object\n");
+	ecore_evas_free(info->ee);
+	return NULL;
+    }
+
+    evas_object_resize(rect, info->w, info->h);
+    evas_object_color_set(rect, 0, 0, 0, 0);
+    return rect;
+}
+
+/* End of a file */
diff --git a/dynamicbox/src/virtual_window_wayland.c b/dynamicbox/src/virtual_window_wayland.c
new file mode 100644
index 0000000..15b668a
--- /dev/null
+++ b/dynamicbox/src/virtual_window_wayland.c
@@ -0,0 +1,449 @@
+/*
+ * Copyright 2013  Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <Elementary.h>
+#include <string.h>
+#include <Ecore_Evas.h>
+#include <Ecore_X.h>
+#include <Evas.h>
+
+#include <dlog.h>
+#include <dynamicbox_errno.h>
+#include <dynamicbox_service.h>
+
+#include "dynamicbox.h"
+#include "debug.h"
+
+#define IS_PD 1
+
+#define PUBLIC __attribute__((visibility("default")))
+
+/*!
+ * \brief
+ * Abstracted Data Type of Virtual Window
+ */
+struct info {
+    char *id; /*!< Identification */
+    struct dynamicbox_buffer *handle; /*!< Livebox buffer handle */
+    int is_hw; /*!< 1 if a buffer is created on the H/W accelerated place or 0 */
+    Ecore_Evas *ee;
+    Evas *e;
+    int is_gbar;
+};
+
+static inline Evas_Object *get_highlighted_object(Evas_Object *obj)
+{
+    Evas_Object *o, *ho;
+
+    o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
+    if (!o) return NULL;
+
+    ho = evas_object_data_get(o, "_elm_access_target");
+    return ho;
+}
+
+/*!
+ * \note
+ * Every user event (mouse) on the buffer will be passed via this event callback
+ */
+static int event_handler_cb(struct dynamicbox_buffer *handler, struct dynamicbox_buffer_event_data *event_info, void *data)
+{
+    struct info *info = data;
+    Elm_Access_Action_Info action_info;
+    Elm_Access_Action_Type action_type;
+    int ret = 0;
+    Evas_Object *parent_elm;
+
+
+    if (!info->handle) {
+	/* Just ignore this event */
+	return 0;
+    }
+
+    /*!
+     * \note
+     * Feed up events
+     */
+    switch (event_info->type) {
+	case DBOX_BUFFER_EVENT_ENTER:
+	    evas_event_feed_mouse_in(info->e, event_info->timestamp * 1000, NULL);
+	    break;
+	case DBOX_BUFFER_EVENT_LEAVE:
+	    evas_event_feed_mouse_out(info->e, event_info->timestamp * 1000, NULL);
+	    break;
+	case DBOX_BUFFER_EVENT_DOWN:
+	    /*!
+	     * \note
+	     * Calculate the event occurred X & Y on the buffer
+	     */
+	    evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, (event_info->timestamp - 0.001f) * 1000, NULL); /* + 0.1f just for fake event */
+	    evas_event_feed_mouse_down(info->e, 1, EVAS_BUTTON_NONE, event_info->timestamp * 1000, NULL); /* + 0.2f just for fake event */
+	    break;
+	case DBOX_BUFFER_EVENT_MOVE:
+	    /*!
+	     * \note
+	     * Calculate the event occurred X & Y on the buffer
+	     */
+	    evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, event_info->timestamp * 1000, NULL);
+	    break;
+	case DBOX_BUFFER_EVENT_UP:
+	    evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, event_info->timestamp * 1000, NULL);
+	    evas_event_feed_mouse_up(info->e, 1, EVAS_BUTTON_NONE, (event_info->timestamp + 0.001f) * 1000, NULL);
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_HIGHLIGHT;
+	    /*!
+	     * \note
+	     * Calculate the event occurred X & Y on the buffer
+	     */
+	    action_info.x = event_info->info.pointer.x;
+	    action_info.y = event_info->info.pointer.y;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    if (ret == EINA_TRUE) {
+		if (!get_highlighted_object(parent_elm)) {
+		    LOGE("Highlighted object is not found\n");
+		    ret = DBOX_ACCESS_STATUS_ERROR;
+		} else {
+		    LOGD("Highlighted object is found\n");
+		    ret = DBOX_ACCESS_STATUS_DONE;
+		}
+	    } else {
+		LOGE("Action error\n");
+		ret = DBOX_ACCESS_STATUS_ERROR;
+	    }
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_NEXT:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
+	    action_info.highlight_cycle = EINA_FALSE;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_LAST : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_PREV:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
+	    action_info.highlight_cycle = EINA_FALSE;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_FIRST : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_ACTIVATE:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_ACTIVATE;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_ACTION_UP:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_UP;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_ACTION_DOWN:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_DOWN;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_SCROLL_UP:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_SCROLL;
+	    action_info.x = event_info->info.pointer.x;
+	    action_info.y = event_info->info.pointer.y;
+	    action_info.mouse_type = 2;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_SCROLL_MOVE:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_SCROLL;
+	    action_info.x = event_info->info.pointer.x;
+	    action_info.y = event_info->info.pointer.y;
+	    action_info.mouse_type = 1;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_SCROLL_DOWN:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_SCROLL;
+	    action_info.x = event_info->info.pointer.x;
+	    action_info.y = event_info->info.pointer.y;
+	    action_info.mouse_type = 0;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_ACCESS_UNHIGHLIGHT:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+	    memset(&action_info, 0, sizeof(action_info));
+	    action_type = ELM_ACCESS_ACTION_UNHIGHLIGHT;
+	    ret = elm_access_action(parent_elm, action_type, &action_info);
+	    ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
+	    break;
+	case DBOX_BUFFER_EVENT_KEY_DOWN:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+
+	    ret = DBOX_KEY_STATUS_ERROR;
+	    break;
+	case DBOX_BUFFER_EVENT_KEY_UP:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+
+	    ret = DBOX_KEY_STATUS_ERROR;
+	    break;
+	case DBOX_BUFFER_EVENT_KEY_FOCUS_IN:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+
+	    ret = DBOX_KEY_STATUS_ERROR;
+	    break;
+	case DBOX_BUFFER_EVENT_KEY_FOCUS_OUT:
+	    parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
+	    if (!parent_elm) {
+		ret = DBOX_ACCESS_STATUS_ERROR;
+		break;
+	    }
+
+	    ret = DBOX_KEY_STATUS_ERROR;
+	    break;
+	default:
+	    LOGD("Unhandled buffer event (%d)\n", event_info->type);
+	    break;
+    }
+
+    return ret;
+}
+
+static void *alloc_fb(void *data, int size)
+{
+    struct info *info = data;
+    void *buffer;
+    int width = 0;
+    int height = 0;
+
+    if (info->ee == NULL) {
+	width = 1;
+	height = 1;
+    } else {
+	ecore_evas_geometry_get(info->ee, NULL, NULL, &width, &height);
+    }
+
+    /*!
+     * Acquire a buffer for canvas.
+     */
+    info->handle = dynamicbox_acquire_buffer(info->id, info->is_gbar,
+	    width, height,
+	    event_handler_cb, info);
+
+    /*!
+     * If it supports the H/W accelerated buffer,
+     * Use it.
+     */
+    if (dynamicbox_support_hw_buffer(info->handle)) {
+	if (dynamicbox_create_hw_buffer(info->handle) == 0) {
+	    buffer = dynamicbox_buffer_hw_buffer(info->handle);
+	    if (buffer) {
+		LOGD("HW Accelerated buffer is created\n");
+		info->is_hw = 1;
+		return buffer;
+	    }
+	}
+
+	LOGE("Failed to allocate HW Accelerated buffer\n");
+    }
+
+    /*!
+     * Or use the buffer of a S/W backend.
+     */
+    buffer = dynamicbox_ref_buffer(info->handle);
+    LOGD("SW buffer is created\n");
+    info->is_hw = 0;
+    return buffer;
+}
+
+static void free_fb(void *data, void *ptr)
+{
+    struct info *info = data;
+
+    if (!info->handle) {
+	return;
+    }
+
+    if (info->is_hw) {
+	if (dynamicbox_destroy_hw_buffer(info->handle) == 0) {
+	    LOGD("HW Accelerated buffer is destroyed\n");
+	    goto out;
+	}
+    }
+
+    dynamicbox_unref_buffer(ptr);
+    LOGD("SW buffer is destroyed\n");
+out:
+    dynamicbox_release_buffer(info->handle);
+    info->handle = NULL;
+}
+
+static void pre_render_cb(void *data, Evas *e, void *event_info)
+{
+    struct info *info = data;
+
+    if (!info->handle) {
+	return;
+    }
+
+    if (info->is_hw) {
+	dynamicbox_buffer_pre_render(info->handle);
+    }
+}
+
+static void post_render_cb(void *data, Evas *e, void *event_info)
+{
+    struct info *info = data;
+
+    if (!info->handle) {
+	return;
+    }
+
+    if (info->is_hw) {
+	dynamicbox_buffer_post_render(info->handle);
+    } else {
+	dynamicbox_sync_buffer(info->handle);
+    }
+}
+
+PUBLIC void *dynamicbox_get_evas_object(const char *id, int is_gbar)
+{
+    struct info *info;
+    Evas_Object *rect;
+
+    if (!id) {
+	ErrPrint("Invalid parameter\n");
+	return NULL;
+    }
+
+    info = calloc(1, sizeof(*info));
+    if (!info) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	return NULL;
+    }
+
+    info->id = strdup(id);
+    if (!info->id) {
+	ErrPrint("Heap: %s\n", strerror(errno));
+	free(info);
+	return NULL;
+    }
+
+    info->is_gbar = is_gbar;
+
+    info->ee = ecore_evas_buffer_allocfunc_new(1, 1, alloc_fb, free_fb, info);
+    if (!info->ee) {
+	ErrPrint("Failed to create ecore_evas (%dx%d)\n", 1, 1);
+	free(info->id);
+	free(info);
+	return NULL;
+    }
+
+    pre_render_cb(info, NULL, NULL);
+    ecore_evas_alpha_set(info->ee, EINA_TRUE);
+    post_render_cb(info, NULL, NULL);
+
+    ecore_evas_data_set(info->ee, "dynamic,box,info", info);
+
+    ecore_evas_manual_render_set(info->ee, EINA_FALSE);
+    ecore_evas_resize(info->ee, 1, 1);
+
+    info->e = ecore_evas_get(info->ee);
+    if (!info->e) {
+	ErrPrint("Failed to get evas\n");
+	ecore_evas_free(info->ee);
+	return NULL;
+    }
+
+    evas_event_callback_add(info->e, EVAS_CALLBACK_RENDER_POST, post_render_cb, info);
+    evas_event_callback_add(info->e, EVAS_CALLBACK_RENDER_PRE, pre_render_cb, info);
+
+    rect = evas_object_rectangle_add(info->e);
+    if (!rect) {
+	ErrPrint("Failed to create evas_object\n");
+	ecore_evas_free(info->ee);
+	return NULL;
+    }
+
+    evas_object_resize(rect, 1, 1);
+    evas_object_color_set(rect, 0, 0, 0, 0);
+    return rect;
+}
+
+/* End of a file */