+#include "PUI.h"
+#include "PUI_internal.h"
+#include <Eina.h>
+
+static int KEY_WL_BUFFER = 0xabcdbeaf;
+static int KEY_CLIENT = 0xdcbabeaf;
+
+static Eina_Bool
+_cb_window_show(void *data, int type EINA_UNUSED, void *event)
+{
+ pui_ani_h handle = (pui_ani_h)data;
+ Ecore_Wl2_Event_Window_Show *ev = (Ecore_Wl2_Event_Window_Show *)event;
+
+ pui_info("...\n");
+
+ /* TODO */
+ (void) handle;
+ (void) ev;
+
+ return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_cb_focus_in(void *data, int type EINA_UNUSED, void *event)
+{
+ pui_ani_h handle = (pui_ani_h)data;
+ Ecore_Wl2_Event_Focus_In *ev = (Ecore_Wl2_Event_Focus_In *)event;
+
+ pui_info("...\n");
+
+ /* TODO */
+ (void) handle;
+ (void) ev;
+
+ return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_cb_focus_out(void *data, int type EINA_UNUSED, void *event)
+{
+ pui_ani_h handle = (pui_ani_h)data;
+ Ecore_Wl2_Event_Focus_Out *ev = (Ecore_Wl2_Event_Focus_Out *)event;
+
+ pui_info("...\n");
+
+ /* TODO */
+ (void) handle;
+ (void) ev;
+
+ return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_cb_visibility_change(void *data, int type EINA_UNUSED, void *event)
+{
+ pui_ani_h handle = (pui_ani_h)data;
+ pui_h ph = handle->pui_handle;
+
+ Ecore_Wl2_Event_Window_Visibility_Change *ev;
+ PUI_Event_Animation_Status *e = NULL;
+
+ ev = event;
+
+ pui_info("Visibility change (window=0x%x, fully_obscured=%d)\n", ev->win, ev->fully_obscured);
+
+ ph->visiblity = !(ev->fully_obscured);
+
+ if (ev->fully_obscured)
+ {
+ //TODO : e
+ if (handle->status == PUI_ANI_STATUS_RUNNING)
+ {
+ handle->status = PUI_ANI_STATUS_STOPPED;
+
+ //PUI_Event_Animation_Status e;
+ if (e = (PUI_Event_Animation_Status *)calloc(1, sizeof(PUI_Event_Animation_Status)))
+ {
+ e->win = ev->win;
+ e->status = PUI_ANI_STATUS_FORCE_STOPPED;
+
+ ecore_event_add(PUI_EVENT_ANI_STOPPED, e, NULL, handle);
+ }
+ }
+ }
+ else
+ {
+ //TODO : e
+ if (e = (PUI_Event_Animation_Status *)calloc(1, sizeof(PUI_Event_Animation_Status)))
+ {
+ e->win = ev->win;
+ e->status = handle->status;
+
+ if (handle->status == PUI_ANI_STATUS_STOPPED)
+ {
+ ecore_event_add(PUI_EVENT_ANI_READY_TO_START, e, NULL, handle);
+ }
+ else if(handle->status == PUI_ANI_STATUS_PAUSED)
+ {
+ ecore_event_add(PUI_EVENT_ANI_READY_TO_RESUME, e, NULL, handle);
+ }
+ }
+ }
+
+ return ECORE_CALLBACK_PASS_ON;
+}
+
+static void
+_buffer_release(void *data, struct wl_buffer *buffer)
+{
+ tbm_surface_h surface = (tbm_surface_h)data;
+ pui_h handle;
+
+ tbm_surface_internal_get_user_data(surface, (unsigned long)&KEY_CLIENT, (void **)&handle);
+ tbm_surface_queue_release(handle->tbm_queue, surface);
+
+ pui_info("[UPDATE] release wl_buffer:%p, surface:%p\n", buffer, surface);
+}
+
+static const struct wl_buffer_listener buffer_listener = {
+ _buffer_release
+};
+
+pui_ani_control_buffer *
+pui_ani_get_buffer(pui_ani_h ani_h)
+{
+ pui_h handle = NULL;
+ tbm_surface_error_e ret;
+ tbm_surface_h surface;
+ pui_ani_control_buffer *buffer = NULL;
+
+ if (!ani_h)
+ {
+ pui_err(\r"Invalid pui ani handle !\n");
+ return NULL;
+ }
+
+ handle = ani_h->pui_handle;
+
+ if (!handle)
+ {
+ pui_err("Error : PUI_INT_ERROR_INVALID_HANDLE\n");
+ return NULL;
+ }
+
+ if (handle->current_surface)
+ {
+ pui_warn("Current_surface is not used !\n");
+ }
+
+ if (!tbm_surface_queue_can_dequeue(handle->tbm_queue, 0))
+ {
+ pui_err("[UPDATE] Cannot dequeue (error : PUI_ERROR_INTERNAL)\n");
+ return NULL;
+ }
+
+ ret = tbm_surface_queue_dequeue(handle->tbm_queue, &surface);
+
+ if (ret != TBM_SURFACE_ERROR_NONE)
+ {
+ pui_err("[UPDATE] dequeue err:%d\n", ret);
+ return NULL;
+ }
+
+ tbm_surface_map(surface, TBM_SURF_OPTION_READ | TBM_SURF_OPTION_WRITE, &handle->sinfo);
+
+ handle->current_surface = surface;
+ buffer = (pui_ani_control_buffer *)&(handle->sinfo.planes[0]);
+
+ return buffer;
+}
+
+pui_int_error
+pui_ani_set_buffer(pui_ani_h ani_h, pui_ani_control_buffer *buffer)
+{
+ pui_h handle = NULL;
+
+ if (!ani_h)
+ {
+ pui_err("Invalid ani handle !\n");
+ return PUI_INT_ERROR_INVALID_HANDLE;
+ }
+
+ handle = ani_h->pui_handle;
+
+ if (!handle)
+ {
+ pui_err("Error : PUI_INT_ERROR_INVALID_HANDLE\n");
+ return PUI_INT_ERROR_INVALID_HANDLE;
+ }
+
+ if (!handle->current_surface)
+ {
+ pui_err("Current_surface is not valid !\n");
+ return PUI_INT_ERROR_INVALID_SURFACE;
+ }
+
+ if (!buffer || !buffer->ptr || !buffer->size)
+ return PUI_INT_ERROR_INVALID_BUFFER;
+
+ handle->is_buffer_set = 1;
+
+ return PUI_INT_ERROR_NONE;
+}
+
+pui_int_error
+pui_ani_update(pui_ani_h ani_h)
+{
+ tbm_surface_h surface;
+ tbm_surface_error_e ret;
+
+ pui_h handle = NULL;
+
+ if (!ani_h)
+ {
+ pui_err("Invalid ani handle !\n");
+ return PUI_INT_ERROR_INVALID_HANDLE;
+ }
+
+ handle = ani_h->pui_handle;
+
+ if (!handle)
+ {
+ pui_err("Error : PUI_INT_ERROR_INVALID_HANDLE\n");
+ return PUI_INT_ERROR_INVALID_HANDLE;
+ }
+
+ if (!handle->current_surface)
+ return PUI_INT_ERROR_INVALID_SURFACE;
+
+ if (!handle->is_buffer_set)
+ {
+ pui_err("Buffer is not set !\n");
+ return PUI_INT_ERROR_INVALID_BUFFER;
+ }
+
+ surface = handle->current_surface;
+ handle->current_surface = NULL;
+
+ tbm_surface_unmap(surface);
+
+ ret = tbm_surface_queue_enqueue(handle->tbm_queue, surface);
+
+ if (ret != TBM_SURFACE_ERROR_NONE)
+ {
+ pui_err("[UPDATE] enqueue err:%d\n", ret);
+ return;
+ }
+
+ ret = tbm_surface_queue_acquire(handle->tbm_queue, &surface);
+
+ if (ret != TBM_SURFACE_ERROR_NONE)
+ {
+ pui_err("[UPDATE] acquire err:%d\n", ret);
+ return;
+ }
+
+ if (!tbm_surface_internal_get_user_data(surface, (unsigned long)&KEY_WL_BUFFER, (void **)&wl_buffer)) {
+ wl_buffer = wayland_tbm_client_create_buffer(handle->wl_tbm_client, surface);
+
+ if (!wl_buffer)
+ {
+ pui_err("[UPDATE] failed to create wl_buffer tbm_surface:%p\n", surface);
+ return;
+ }
+
+ wl_buffer_add_listener(wl_buffer, &buffer_listener, surface);
+
+ tbm_surface_internal_add_user_data(surface, (unsigned long)&KEY_WL_BUFFER, NULL);
+ tbm_surface_internal_set_user_data(surface, (unsigned long)&KEY_WL_BUFFER, wl_buffer);
+ tbm_surface_internal_add_user_data(surface, (unsigned long)&KEY_CLIENT, NULL);
+ tbm_surface_internal_set_user_data(surface, (unsigned long)&KEY_CLIENT, handle);
+ }
+
+ if (!wl_buffer)
+ {
+ pui_err("[UPDATE] dequeue err:%d\n", ret);
+ return;
+ }
+
+ ecore_wl2_window_buffer_attach(handle->win, wl_buffer, 0, 0, 0);
+ ecore_wl2_window_damage(handle->win, NULL, 0);
+ ecore_wl2_window_commit(handle->win, EINA_TRUE);
+
+ pui_info("[UPDATE] commit wl_buffer:%p, surface:%p\n", wl_buffer, surface);
+
+ handle->is_buffer_set = 0;
+
+ return PUI_INT_ERROR_NONE;
+}
+
+static void
+_pui_ani_event_handlers_init(pui_ani_h ani_h)
+{
+ Ecore_Event_Handler *h = NULL;
+
+ if (!ani_h)
+ {
+ pui_err("Invalid handle !\n");
+ return;
+ }
+
+ if (!ani_h->ecore_event_hdls)
+ ani_h->ecore_event_hdls = eina_array_new(5);
+
+ h = ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_SHOW, _cb_window_show, handle);
+ eina_array_push(ani_h->_ecore_event_hdls, h);
+
+ h = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_IN, _cb_focus_in, handle);
+ eina_array_push(ani_h->_ecore_event_hdls, h);
+
+ h = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_OUT, _cb_focus_out, handle);
+ eina_array_push(ani_h->_ecore_event_hdls, h);
+
+ h = ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_VISIBILITY_CHANGE, _cb_visibility_change, handle);
+ eina_array_push(ani_h->_ecore_event_hdls, h);
+
+}
+
+static void
+_pui_ani_event_handlers_shutdown(pui_ani_h ani_h)
+{
+ if (!ani_h)
+ {
+ pui_err("Invalid handle !\n");
+ return;
+ }
+
+ while (eina_array_count(ani_h->_ecore_event_hdls))
+ ecore_event_handler_del(eina_array_pop(ani_h->_ecore_event_hdls));
+ eina_array_free(ani_h->_ecore_event_hdls);
+
+ ani_h->_ecore_event_hdls = NULL;
+}
+
+pui_id
+pui_ani_get_id(pui_ani_h ani_h)
+{
+ if (ani_h && ani_h->id)
+ return ani_h->id;
+}
+
+pui_ani_cmd
+pui_ani_get_cmd(pui_ani_h ani_h)
+{
+ if (ani_h && ani_h->cmd)
+ return ani_h->cmd;
+}
+
+pui_ani_opt
+pui_ani_get_opt(pui_ani_h ani_h)
+{
+ if (ani_h && ani_h->opt)
+ return ani_h->opt;
+}
+
+pui_error
+pui_ani_control(pui_ani_h ani_h, pui_ani_cmd cmd, pui_ani_opt opt)
+{
+ if (!ani_h)
+ return PUI_ERROR_INVALID_ANI_HANDLE;
+
+ if (cmd < PUI_ANI_CMD_START || cmd >= PUI_ANI_CMD_LAST)
+ return PUI_ERROR_INVALID_ANI_CMD;
+
+ if (opt < PUI_ANI_OPT_NONE || opt >= PUI_ANI_OPT_LAST)
+ return PUI_ERROR_INVALID_ANI_OPT;
+
+ if (ani_h->id && ani_h->status == PUI_ANI_STATUS_RUNNING)
+ {
+
+ }
+
+ ani_h->cmd = cmd;
+ ani_h->opt = opt;
+ ani_h->status = PUI_ANI_STATUS_STOPPED;
+
+ ani_h->frame_cb = ecore_wl2_window_frame_callback_add(win, _pui_cb_frame, handle);
+
+ if (!ani_h->frame_cb)
+ {
+ pui_err("Failed to add frame callback !");
+ goto err;
+ }
+
+ //TODO
+
+ return PUI_ERROR_NONE;
+
+err:
+ return PUI_ERROR_INTERNAL;
+}
+
+pui_ani_h
+pui_ani_create(pui_h handle, pui_id id)
+{
+ pui_ani_h ani_h = NULL;
+ pui_ani_mgr *ani_mgr = NULL;
+ pui_backend_ani_func *ani_func = NULL;
+
+ if (!handle || !handle->backend_module_data))
+ {
+ pui_err("Invalid pui handle or backend module data !\n");
+ return NULL;
+ }
+
+ ani_func = handle->backend_module_data->get_ani_func(id);
+
+ if (!ani_func)
+ {
+ pui_err("Invalid ani func from backend module data !\n");
+ return NULL;
+ }
+
+ ani_h = (pui_ani_h)calloc(1, sizeof(pui_ani_h));
+
+ if (!ani_h)
+ {
+ pui_err("Failed to allocate memory for pui ani handle !\n");
+ return NULL;
+ }
+
+ ani_h->ecore_event_hdls = NULL;
+ _pui_ani_event_handlers_init(ani_h);
+
+ ani_mgr = (pui_ani_mgr *)calloc(1, sizeof(pui_ani_mgr));
+
+ if (!ani_mgr)
+ {
+ pui_err("Failed to allocate memory for pui ani mgr !\n");
+ goto err;
+ }
+
+ ani_mgr->ani_h = ani_h;
+ ani_mgr->id = id;
+ ani_mgr->status = PUI_ANI_STATUS_INITIAL;
+ ani_mgr->ani_func = ani_func;
+
+ return ani_h;
+
+err:
+ if (ani_h)
+ free(ani_h);
+ return NULL;
+}
+
+void
+pui_ani_destroy(pui_ani_h ani_h)
+{
+ if (!ani_h)
+ return;
+
+ if (ani_h->ani_mgr->status != PUI_ANI_STATUS_STOPPED)
+ pui_ani_control(ani_h, PUI_ANI_CMD_STOP, PUI_ANI_OPT_NONE);
+ free(ani_h->ani_mgr);
+
+ _pui_ani_event_handlers_shutdown(ani_h);
+
+ if (ani_h->frame_cb)
+ {
+ ecore_wl2_window_frame_callback_del(ani_h->frame_cb);
+ ani_h->frame_cb = NULL;
+ }
+}
+