src/PUI_ani.c

   1 #include "PUI.h"
   2 #include "PUI_internal.h"
   3 #include <Eina.h>
   4
   5 static int KEY_WL_BUFFER = 0xabcdbeaf;
   6 static int KEY_CLIENT = 0xdcbabeaf;
   7
   8 static Eina_Bool
   9 _cb_window_show(void *data, int type EINA_UNUSED, void *event)
  10 {
  11         pui_ani_h handle =  (pui_ani_h)data;
  12         Ecore_Wl2_Event_Window_Show *ev = (Ecore_Wl2_Event_Window_Show *)event;
  13
  14         pui_info("...\n");
  15
  16         /* TODO */
  17         (void) handle;
  18         (void) ev;
  19
  20         return ECORE_CALLBACK_PASS_ON;
  21 }
  22
  23 static Eina_Bool
  24 _cb_focus_in(void *data, int type EINA_UNUSED, void *event)
  25 {
  26         pui_ani_h handle =  (pui_ani_h)data;
  27         Ecore_Wl2_Event_Focus_In *ev = (Ecore_Wl2_Event_Focus_In *)event;
  28
  29         pui_info("...\n");
  30
  31         /* TODO */
  32         (void) handle;
  33         (void) ev;
  34
  35         return ECORE_CALLBACK_PASS_ON;
  36 }
  37
  38 static Eina_Bool
  39 _cb_focus_out(void *data, int type EINA_UNUSED, void *event)
  40 {
  41         pui_ani_h handle =  (pui_ani_h)data;
  42         Ecore_Wl2_Event_Focus_Out *ev = (Ecore_Wl2_Event_Focus_Out *)event;
  43
  44         pui_info("...\n");
  45
  46         /* TODO */
  47         (void) handle;
  48         (void) ev;
  49
  50         return ECORE_CALLBACK_PASS_ON;
  51 }
  52
  53 static Eina_Bool
  54 _cb_visibility_change(void *data, int type EINA_UNUSED, void *event)
  55 {
  56         pui_ani_h handle =  (pui_ani_h)data;
  57         pui_h ph = handle->pui_handle;
  58
  59         Ecore_Wl2_Event_Window_Visibility_Change *ev;
  60         PUI_Event_Animation_Status *e = NULL;
  61
  62         ev = event;
  63
  64         pui_info("Visibility change (window=0x%x, fully_obscured=%d)\n", ev->win, ev->fully_obscured);
  65
  66         ph->visiblity = !(ev->fully_obscured);
  67
  68         if (ev->fully_obscured)
  69         {
  70                 //TODO : e
  71                 if (handle->status == PUI_ANI_STATUS_RUNNING)
  72                 {
  73                         handle->status = PUI_ANI_STATUS_STOPPED;
  74
  75                         //PUI_Event_Animation_Status e;
  76                         if (e = (PUI_Event_Animation_Status *)calloc(1, sizeof(PUI_Event_Animation_Status)))
  77                         {
  78                                 e->win = ev->win;
  79                                 e->status = PUI_ANI_STATUS_FORCE_STOPPED;
  80
  81                                 ecore_event_add(PUI_EVENT_ANI_STOPPED, e, NULL, handle);
  82                         }
  83                 }
  84         }
  85         else
  86         {
  87                 //TODO : e
  88                 if (e = (PUI_Event_Animation_Status *)calloc(1, sizeof(PUI_Event_Animation_Status)))
  89                 {
  90                         e->win = ev->win;
  91                         e->status = handle->status;
  92
  93                         if (handle->status == PUI_ANI_STATUS_STOPPED)
  94                         {
  95                                 ecore_event_add(PUI_EVENT_ANI_READY_TO_START, e, NULL, handle);
  96                         }
  97                         else if(handle->status == PUI_ANI_STATUS_PAUSED)
  98                         {
  99                                 ecore_event_add(PUI_EVENT_ANI_READY_TO_RESUME, e, NULL, handle);
 100                         }
 101                 }
 102         }
 103
 104         return ECORE_CALLBACK_PASS_ON;
 105 }
 106
 107 static void
 108 _buffer_release(void *data, struct wl_buffer *buffer)
 109 {
 110         tbm_surface_h surface = (tbm_surface_h)data;
 111         pui_h handle;
 112
 113         tbm_surface_internal_get_user_data(surface, (unsigned long)&KEY_CLIENT, (void **)&handle);
 114         tbm_surface_queue_release(handle->tbm_queue, surface);
 115
 116         pui_info("[UPDATE] release wl_buffer:%p, surface:%p\n", buffer, surface);
 117 }
 118
 119 static const struct wl_buffer_listener buffer_listener = {
 120     _buffer_release
 121 };
 122
 123 pui_ani_control_buffer *
 124 pui_ani_get_buffer(pui_ani_h ani_h)
 125 {
 126         pui_h handle = NULL;
 127         tbm_surface_error_e ret;
 128         tbm_surface_h surface;
 129         pui_ani_control_buffer *buffer = NULL;
 130
 131         if (!ani_h)
 132         {
 133                 pui_err(\r"Invalid pui ani handle !\n");
 134                 return NULL;
 135         }
 136
 137         handle = ani_h->pui_handle;
 138
 139         if (!handle)
 140         {
 141                 pui_err("Error : PUI_INT_ERROR_INVALID_HANDLE\n");
 142                 return NULL;
 143         }
 144
 145         if (handle->current_surface)
 146         {
 147                 pui_warn("Current_surface is not used !\n");
 148         }
 149
 150         if (!tbm_surface_queue_can_dequeue(handle->tbm_queue, 0))
 151         {
 152                 pui_err("[UPDATE] Cannot dequeue (error : PUI_ERROR_INTERNAL)\n");
 153                 return NULL;
 154         }
 155
 156         ret = tbm_surface_queue_dequeue(handle->tbm_queue, &surface);
 157
 158         if (ret != TBM_SURFACE_ERROR_NONE)
 159         {
 160                 pui_err("[UPDATE] dequeue err:%d\n", ret);
 161                 return NULL;
 162         }
 163
 164         tbm_surface_map(surface, TBM_SURF_OPTION_READ | TBM_SURF_OPTION_WRITE, &handle->sinfo);
 165
 166         handle->current_surface = surface;
 167         buffer = (pui_ani_control_buffer *)&(handle->sinfo.planes[0]);
 168
 169         return buffer;
 170 }
 171
 172 pui_int_error
 173 pui_ani_set_buffer(pui_ani_h ani_h, pui_ani_control_buffer *buffer)
 174 {
 175         pui_h handle = NULL;
 176
 177         if (!ani_h)
 178         {
 179                 pui_err("Invalid ani handle !\n");
 180                 return PUI_INT_ERROR_INVALID_HANDLE;
 181         }
 182
 183         handle = ani_h->pui_handle;
 184
 185         if (!handle)
 186         {
 187                 pui_err("Error : PUI_INT_ERROR_INVALID_HANDLE\n");
 188                 return PUI_INT_ERROR_INVALID_HANDLE;
 189         }
 190
 191         if (!handle->current_surface)
 192         {
 193                 pui_err("Current_surface is not valid !\n");
 194                 return PUI_INT_ERROR_INVALID_SURFACE;
 195         }
 196
 197         if (!buffer || !buffer->ptr || !buffer->size)
 198                 return PUI_INT_ERROR_INVALID_BUFFER;
 199
 200         handle->is_buffer_set = 1;
 201
 202         return PUI_INT_ERROR_NONE;
 203 }
 204
 205 pui_int_error
 206 pui_ani_update(pui_ani_h ani_h)
 207 {
 208         tbm_surface_h surface;
 209         tbm_surface_error_e ret;
 210
 211         pui_h handle = NULL;
 212
 213         if (!ani_h)
 214         {
 215                 pui_err("Invalid ani handle !\n");
 216                 return PUI_INT_ERROR_INVALID_HANDLE;
 217         }
 218
 219         handle = ani_h->pui_handle;
 220
 221         if (!handle)
 222         {
 223                 pui_err("Error : PUI_INT_ERROR_INVALID_HANDLE\n");
 224                 return PUI_INT_ERROR_INVALID_HANDLE;
 225         }
 226
 227         if (!handle->current_surface)
 228                 return PUI_INT_ERROR_INVALID_SURFACE;
 229
 230         if (!handle->is_buffer_set)
 231         {
 232                 pui_err("Buffer is not set !\n");
 233                 return PUI_INT_ERROR_INVALID_BUFFER;
 234         }
 235
 236         surface = handle->current_surface;
 237         handle->current_surface = NULL;
 238
 239         tbm_surface_unmap(surface);
 240
 241         ret = tbm_surface_queue_enqueue(handle->tbm_queue, surface);
 242
 243         if (ret != TBM_SURFACE_ERROR_NONE)
 244         {
 245                 pui_err("[UPDATE] enqueue err:%d\n", ret);
 246                 return;
 247         }
 248
 249         ret = tbm_surface_queue_acquire(handle->tbm_queue, &surface);
 250
 251         if (ret != TBM_SURFACE_ERROR_NONE)
 252         {
 253                 pui_err("[UPDATE] acquire err:%d\n", ret);
 254                 return;
 255         }
 256
 257         if (!tbm_surface_internal_get_user_data(surface, (unsigned long)&KEY_WL_BUFFER, (void **)&wl_buffer)) {
 258                 wl_buffer = wayland_tbm_client_create_buffer(handle->wl_tbm_client, surface);
 259
 260                 if (!wl_buffer)
 261                 {
 262                         pui_err("[UPDATE] failed to create wl_buffer tbm_surface:%p\n", surface);
 263                         return;
 264                 }
 265
 266                 wl_buffer_add_listener(wl_buffer, &buffer_listener, surface);
 267
 268                 tbm_surface_internal_add_user_data(surface, (unsigned long)&KEY_WL_BUFFER, NULL);
 269                 tbm_surface_internal_set_user_data(surface, (unsigned long)&KEY_WL_BUFFER, wl_buffer);
 270                 tbm_surface_internal_add_user_data(surface, (unsigned long)&KEY_CLIENT, NULL);
 271                 tbm_surface_internal_set_user_data(surface, (unsigned long)&KEY_CLIENT, handle);
 272         }
 273
 274         if (!wl_buffer)
 275         {
 276                 pui_err("[UPDATE] dequeue err:%d\n", ret);
 277                 return;
 278         }
 279
 280         ecore_wl2_window_buffer_attach(handle->win, wl_buffer, 0, 0, 0);
 281         ecore_wl2_window_damage(handle->win, NULL, 0);
 282         ecore_wl2_window_commit(handle->win, EINA_TRUE);
 283
 284         pui_info("[UPDATE] commit wl_buffer:%p, surface:%p\n", wl_buffer, surface);
 285
 286         handle->is_buffer_set = 0;
 287
 288         return PUI_INT_ERROR_NONE;
 289 }
 290
 291 static void
 292 _pui_ani_event_handlers_init(pui_ani_h ani_h)
 293 {
 294         Ecore_Event_Handler *h = NULL;
 295
 296         if (!ani_h)
 297         {
 298                 pui_err("Invalid handle !\n");
 299                 return;
 300         }
 301
 302         if (!ani_h->ecore_event_hdls)
 303                 ani_h->ecore_event_hdls = eina_array_new(5);
 304
 305         h = ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_SHOW, _cb_window_show, handle);
 306         eina_array_push(ani_h->_ecore_event_hdls, h);
 307
 308         h = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_IN, _cb_focus_in, handle);
 309         eina_array_push(ani_h->_ecore_event_hdls, h);
 310
 311         h = ecore_event_handler_add(ECORE_WL2_EVENT_FOCUS_OUT, _cb_focus_out, handle);
 312         eina_array_push(ani_h->_ecore_event_hdls, h);
 313
 314         h = ecore_event_handler_add(ECORE_WL2_EVENT_WINDOW_VISIBILITY_CHANGE, _cb_visibility_change, handle);
 315         eina_array_push(ani_h->_ecore_event_hdls, h);
 316
 317 }
 318
 319 static void
 320 _pui_ani_event_handlers_shutdown(pui_ani_h ani_h)
 321 {
 322         if (!ani_h)
 323         {
 324                 pui_err("Invalid handle !\n");
 325                 return;
 326         }
 327
 328         while (eina_array_count(ani_h->_ecore_event_hdls))
 329                 ecore_event_handler_del(eina_array_pop(ani_h->_ecore_event_hdls));
 330         eina_array_free(ani_h->_ecore_event_hdls);
 331
 332         ani_h->_ecore_event_hdls = NULL;
 333 }
 334
 335 pui_id
 336 pui_ani_get_id(pui_ani_h ani_h)
 337 {
 338         if (ani_h && ani_h->id)
 339                 return ani_h->id;
 340 }
 341
 342 pui_ani_cmd
 343 pui_ani_get_cmd(pui_ani_h ani_h)
 344 {
 345         if (ani_h && ani_h->cmd)
 346                 return ani_h->cmd;
 347 }
 348
 349 pui_ani_opt
 350 pui_ani_get_opt(pui_ani_h ani_h)
 351 {
 352         if (ani_h && ani_h->opt)
 353                 return ani_h->opt;
 354 }
 355
 356 pui_error
 357 pui_ani_control(pui_ani_h ani_h, pui_ani_cmd cmd, pui_ani_opt opt)
 358 {
 359         if (!ani_h)
 360                 return PUI_ERROR_INVALID_ANI_HANDLE;
 361
 362         if (cmd < PUI_ANI_CMD_START || cmd >= PUI_ANI_CMD_LAST)
 363                 return PUI_ERROR_INVALID_ANI_CMD;
 364
 365         if (opt < PUI_ANI_OPT_NONE || opt >= PUI_ANI_OPT_LAST)
 366                 return PUI_ERROR_INVALID_ANI_OPT;
 367
 368         if (ani_h->id && ani_h->status == PUI_ANI_STATUS_RUNNING)
 369         {
 370
 371         }
 372
 373         ani_h->cmd = cmd;
 374         ani_h->opt = opt;
 375         ani_h->status = PUI_ANI_STATUS_STOPPED;
 376
 377         ani_h->frame_cb = ecore_wl2_window_frame_callback_add(win, _pui_cb_frame, handle);
 378
 379         if (!ani_h->frame_cb)
 380         {
 381                 pui_err("Failed to add frame callback !");
 382                 goto err;
 383         }
 384
 385         //TODO
 386
 387         return PUI_ERROR_NONE;
 388
 389 err:
 390         return PUI_ERROR_INTERNAL;
 391 }
 392
 393 pui_ani_h
 394 pui_ani_create(pui_h handle, pui_id id)
 395 {
 396         pui_ani_h ani_h = NULL;
 397         pui_ani_mgr *ani_mgr = NULL;
 398         pui_backend_ani_func *ani_func = NULL;
 399
 400         if (!handle || !handle->backend_module_data))
 401         {
 402                 pui_err("Invalid pui handle or backend module data !\n");
 403                 return NULL;
 404         }
 405
 406         ani_func = handle->backend_module_data->get_ani_func(id);
 407
 408         if (!ani_func)
 409         {
 410                 pui_err("Invalid ani func from backend module data !\n");
 411                 return NULL;
 412         }
 413
 414         ani_h = (pui_ani_h)calloc(1, sizeof(pui_ani_h));
 415
 416         if (!ani_h)
 417         {
 418                 pui_err("Failed to allocate memory for pui ani handle !\n");
 419                 return NULL;
 420         }
 421
 422         ani_h->ecore_event_hdls = NULL;
 423         _pui_ani_event_handlers_init(ani_h);
 424
 425         ani_mgr = (pui_ani_mgr *)calloc(1, sizeof(pui_ani_mgr));
 426
 427         if (!ani_mgr)
 428         {
 429                 pui_err("Failed to allocate memory for pui ani mgr !\n");
 430                 goto err;
 431         }
 432
 433         ani_mgr->ani_h = ani_h;
 434         ani_mgr->id = id;
 435         ani_mgr->status = PUI_ANI_STATUS_INITIAL;
 436         ani_mgr->ani_func = ani_func;
 437
 438         return ani_h;
 439
 440 err:
 441         if (ani_h)
 442                 free(ani_h);
 443         return NULL;
 444 }
 445
 446 void
 447 pui_ani_destroy(pui_ani_h ani_h)
 448 {
 449         if (!ani_h)
 450                 return;
 451
 452         if (ani_h->ani_mgr->status != PUI_ANI_STATUS_STOPPED)
 453                 pui_ani_control(ani_h, PUI_ANI_CMD_STOP, PUI_ANI_OPT_NONE);
 454         free(ani_h->ani_mgr);
 455
 456         _pui_ani_event_handlers_shutdown(ani_h);
 457
 458         if (ani_h->frame_cb)
 459         {
 460                 ecore_wl2_window_frame_callback_del(ani_h->frame_cb);
 461                 ani_h->frame_cb = NULL;
 462         }
 463 }
 464