src/virtual_window_wayland.c

   1 /*
   2  * Copyright 2013  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <Elementary.h>
  18 #include <string.h>
  19 #include <Ecore_Evas.h>
  20 #include <Ecore_X.h>
  21 #include <Evas.h>
  22
  23 #include <dlog.h>
  24 #include <dynamicbox_errno.h>
  25 #include <dynamicbox_service.h>
  26
  27 #include "dynamicbox.h"
  28 #include "debug.h"
  29
  30 #define IS_PD 1
  31
  32 #define PUBLIC __attribute__((visibility("default")))
  33
  34 /*!
  35  * \brief
  36  * Abstracted Data Type of Virtual Window
  37  */
  38 struct info {
  39     char *id; /*!< Identification */
  40     struct dynamicbox_buffer *handle; /*!< Livebox buffer handle */
  41     int is_hw; /*!< 1 if a buffer is created on the H/W accelerated place or 0 */
  42     Ecore_Evas *ee;
  43     Evas *e;
  44     int is_gbar;
  45 };
  46
  47 static inline Evas_Object *get_highlighted_object(Evas_Object *obj)
  48 {
  49     Evas_Object *o, *ho;
  50
  51     o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
  52     if (!o) return NULL;
  53
  54     ho = evas_object_data_get(o, "_elm_access_target");
  55     return ho;
  56 }
  57
  58 /*!
  59  * \note
  60  * Every user event (mouse) on the buffer will be passed via this event callback
  61  */
  62 static int event_handler_cb(struct dynamicbox_buffer *handler, struct dynamicbox_buffer_event_data *event_info, void *data)
  63 {
  64     struct info *info = data;
  65     Elm_Access_Action_Info action_info;
  66     Elm_Access_Action_Type action_type;
  67     int ret = 0;
  68     Evas_Object *parent_elm;
  69
  70
  71     if (!info->handle) {
  72         /* Just ignore this event */
  73         return 0;
  74     }
  75
  76     /*!
  77      * \note
  78      * Feed up events
  79      */
  80     switch (event_info->type) {
  81         case DBOX_BUFFER_EVENT_ENTER:
  82             evas_event_feed_mouse_in(info->e, event_info->timestamp * 1000, NULL);
  83             break;
  84         case DBOX_BUFFER_EVENT_LEAVE:
  85             evas_event_feed_mouse_out(info->e, event_info->timestamp * 1000, NULL);
  86             break;
  87         case DBOX_BUFFER_EVENT_DOWN:
  88             /*!
  89              * \note
  90              * Calculate the event occurred X & Y on the buffer
  91              */
  92             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 */
  93             evas_event_feed_mouse_down(info->e, 1, EVAS_BUTTON_NONE, event_info->timestamp * 1000, NULL); /* + 0.2f just for fake event */
  94             break;
  95         case DBOX_BUFFER_EVENT_MOVE:
  96             /*!
  97              * \note
  98              * Calculate the event occurred X & Y on the buffer
  99              */
 100             evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, event_info->timestamp * 1000, NULL);
 101             break;
 102         case DBOX_BUFFER_EVENT_UP:
 103             evas_event_feed_mouse_move(info->e, event_info->info.pointer.x, event_info->info.pointer.y, event_info->timestamp * 1000, NULL);
 104             evas_event_feed_mouse_up(info->e, 1, EVAS_BUTTON_NONE, (event_info->timestamp + 0.001f) * 1000, NULL);
 105             break;
 106         case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT:
 107             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 108             if (!parent_elm) {
 109                 ret = DBOX_ACCESS_STATUS_ERROR;
 110                 break;
 111             }
 112             memset(&action_info, 0, sizeof(action_info));
 113             action_type = ELM_ACCESS_ACTION_HIGHLIGHT;
 114             /*!
 115              * \note
 116              * Calculate the event occurred X & Y on the buffer
 117              */
 118             action_info.x = event_info->info.pointer.x;
 119             action_info.y = event_info->info.pointer.y;
 120             ret = elm_access_action(parent_elm, action_type, &action_info);
 121             if (ret == EINA_TRUE) {
 122                 if (!get_highlighted_object(parent_elm)) {
 123                     LOGE("Highlighted object is not found\n");
 124                     ret = DBOX_ACCESS_STATUS_ERROR;
 125                 } else {
 126                     LOGD("Highlighted object is found\n");
 127                     ret = DBOX_ACCESS_STATUS_DONE;
 128                 }
 129             } else {
 130                 LOGE("Action error\n");
 131                 ret = DBOX_ACCESS_STATUS_ERROR;
 132             }
 133             break;
 134         case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_NEXT:
 135             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 136             if (!parent_elm) {
 137                 ret = DBOX_ACCESS_STATUS_ERROR;
 138                 break;
 139             }
 140             memset(&action_info, 0, sizeof(action_info));
 141             action_type = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
 142             action_info.highlight_cycle = EINA_FALSE;
 143             ret = elm_access_action(parent_elm, action_type, &action_info);
 144             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_LAST : DBOX_ACCESS_STATUS_DONE;
 145             break;
 146         case DBOX_BUFFER_EVENT_ACCESS_HIGHLIGHT_PREV:
 147             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 148             if (!parent_elm) {
 149                 ret = DBOX_ACCESS_STATUS_ERROR;
 150                 break;
 151             }
 152             memset(&action_info, 0, sizeof(action_info));
 153             action_type = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
 154             action_info.highlight_cycle = EINA_FALSE;
 155             ret = elm_access_action(parent_elm, action_type, &action_info);
 156             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_FIRST : DBOX_ACCESS_STATUS_DONE;
 157             break;
 158         case DBOX_BUFFER_EVENT_ACCESS_ACTIVATE:
 159             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 160             if (!parent_elm) {
 161                 ret = DBOX_ACCESS_STATUS_ERROR;
 162                 break;
 163             }
 164             memset(&action_info, 0, sizeof(action_info));
 165             action_type = ELM_ACCESS_ACTION_ACTIVATE;
 166             ret = elm_access_action(parent_elm, action_type, &action_info);
 167             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
 168             break;
 169         case DBOX_BUFFER_EVENT_ACCESS_ACTION_UP:
 170             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 171             if (!parent_elm) {
 172                 ret = DBOX_ACCESS_STATUS_ERROR;
 173                 break;
 174             }
 175             memset(&action_info, 0, sizeof(action_info));
 176             action_type = ELM_ACCESS_ACTION_UP;
 177             ret = elm_access_action(parent_elm, action_type, &action_info);
 178             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
 179             break;
 180         case DBOX_BUFFER_EVENT_ACCESS_ACTION_DOWN:
 181             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 182             if (!parent_elm) {
 183                 ret = DBOX_ACCESS_STATUS_ERROR;
 184                 break;
 185             }
 186             memset(&action_info, 0, sizeof(action_info));
 187             action_type = ELM_ACCESS_ACTION_DOWN;
 188             ret = elm_access_action(parent_elm, action_type, &action_info);
 189             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
 190             break;
 191         case DBOX_BUFFER_EVENT_ACCESS_SCROLL_UP:
 192             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 193             if (!parent_elm) {
 194                 ret = DBOX_ACCESS_STATUS_ERROR;
 195                 break;
 196             }
 197             memset(&action_info, 0, sizeof(action_info));
 198             action_type = ELM_ACCESS_ACTION_SCROLL;
 199             action_info.x = event_info->info.pointer.x;
 200             action_info.y = event_info->info.pointer.y;
 201             action_info.mouse_type = 2;
 202             ret = elm_access_action(parent_elm, action_type, &action_info);
 203             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
 204             break;
 205         case DBOX_BUFFER_EVENT_ACCESS_SCROLL_MOVE:
 206             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 207             if (!parent_elm) {
 208                 ret = DBOX_ACCESS_STATUS_ERROR;
 209                 break;
 210             }
 211             memset(&action_info, 0, sizeof(action_info));
 212             action_type = ELM_ACCESS_ACTION_SCROLL;
 213             action_info.x = event_info->info.pointer.x;
 214             action_info.y = event_info->info.pointer.y;
 215             action_info.mouse_type = 1;
 216             ret = elm_access_action(parent_elm, action_type, &action_info);
 217             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
 218             break;
 219         case DBOX_BUFFER_EVENT_ACCESS_SCROLL_DOWN:
 220             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 221             if (!parent_elm) {
 222                 ret = DBOX_ACCESS_STATUS_ERROR;
 223                 break;
 224             }
 225             memset(&action_info, 0, sizeof(action_info));
 226             action_type = ELM_ACCESS_ACTION_SCROLL;
 227             action_info.x = event_info->info.pointer.x;
 228             action_info.y = event_info->info.pointer.y;
 229             action_info.mouse_type = 0;
 230             ret = elm_access_action(parent_elm, action_type, &action_info);
 231             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
 232             break;
 233         case DBOX_BUFFER_EVENT_ACCESS_UNHIGHLIGHT:
 234             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 235             if (!parent_elm) {
 236                 ret = DBOX_ACCESS_STATUS_ERROR;
 237                 break;
 238             }
 239             memset(&action_info, 0, sizeof(action_info));
 240             action_type = ELM_ACCESS_ACTION_UNHIGHLIGHT;
 241             ret = elm_access_action(parent_elm, action_type, &action_info);
 242             ret = (ret == EINA_FALSE) ? DBOX_ACCESS_STATUS_ERROR : DBOX_ACCESS_STATUS_DONE;
 243             break;
 244         case DBOX_BUFFER_EVENT_KEY_DOWN:
 245             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 246             if (!parent_elm) {
 247                 ret = DBOX_ACCESS_STATUS_ERROR;
 248                 break;
 249             }
 250
 251             ret = DBOX_KEY_STATUS_ERROR;
 252             break;
 253         case DBOX_BUFFER_EVENT_KEY_UP:
 254             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 255             if (!parent_elm) {
 256                 ret = DBOX_ACCESS_STATUS_ERROR;
 257                 break;
 258             }
 259
 260             ret = DBOX_KEY_STATUS_ERROR;
 261             break;
 262         case DBOX_BUFFER_EVENT_KEY_FOCUS_IN:
 263             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 264             if (!parent_elm) {
 265                 ret = DBOX_ACCESS_STATUS_ERROR;
 266                 break;
 267             }
 268
 269             ret = DBOX_KEY_STATUS_ERROR;
 270             break;
 271         case DBOX_BUFFER_EVENT_KEY_FOCUS_OUT:
 272             parent_elm = ecore_evas_data_get(info->ee, "dynamic,box,win");
 273             if (!parent_elm) {
 274                 ret = DBOX_ACCESS_STATUS_ERROR;
 275                 break;
 276             }
 277
 278             ret = DBOX_KEY_STATUS_ERROR;
 279             break;
 280         default:
 281             LOGD("Unhandled buffer event (%d)\n", event_info->type);
 282             break;
 283     }
 284
 285     return ret;
 286 }
 287
 288 static void *alloc_fb(void *data, int size)
 289 {
 290     struct info *info = data;
 291     void *buffer;
 292     int width = 0;
 293     int height = 0;
 294
 295     if (info->ee == NULL) {
 296         width = 1;
 297         height = 1;
 298     } else {
 299         ecore_evas_geometry_get(info->ee, NULL, NULL, &width, &height);
 300     }
 301
 302     /*!
 303      * Acquire a buffer for canvas.
 304      */
 305     info->handle = dynamicbox_acquire_buffer(info->id, info->is_gbar,
 306             width, height,
 307             event_handler_cb, info);
 308
 309     /*!
 310      * If it supports the H/W accelerated buffer,
 311      * Use it.
 312      */
 313     if (dynamicbox_support_hw_buffer(info->handle)) {
 314         if (dynamicbox_create_hw_buffer(info->handle) == 0) {
 315             buffer = dynamicbox_buffer_hw_buffer(info->handle);
 316             if (buffer) {
 317                 LOGD("HW Accelerated buffer is created\n");
 318                 info->is_hw = 1;
 319                 return buffer;
 320             }
 321         }
 322
 323         LOGE("Failed to allocate HW Accelerated buffer\n");
 324     }
 325
 326     /*!
 327      * Or use the buffer of a S/W backend.
 328      */
 329     buffer = dynamicbox_ref_buffer(info->handle);
 330     LOGD("SW buffer is created\n");
 331     info->is_hw = 0;
 332     return buffer;
 333 }
 334
 335 static void free_fb(void *data, void *ptr)
 336 {
 337     struct info *info = data;
 338
 339     if (!info->handle) {
 340         return;
 341     }
 342
 343     if (info->is_hw) {
 344         if (dynamicbox_destroy_hw_buffer(info->handle) == 0) {
 345             LOGD("HW Accelerated buffer is destroyed\n");
 346             goto out;
 347         }
 348     }
 349
 350     dynamicbox_unref_buffer(ptr);
 351     LOGD("SW buffer is destroyed\n");
 352 out:
 353     dynamicbox_release_buffer(info->handle);
 354     info->handle = NULL;
 355 }
 356
 357 static void pre_render_cb(void *data, Evas *e, void *event_info)
 358 {
 359     struct info *info = data;
 360
 361     if (!info->handle) {
 362         return;
 363     }
 364
 365     if (info->is_hw) {
 366         dynamicbox_buffer_pre_render(info->handle);
 367     }
 368 }
 369
 370 static void post_render_cb(void *data, Evas *e, void *event_info)
 371 {
 372     struct info *info = data;
 373
 374     if (!info->handle) {
 375         return;
 376     }
 377
 378     if (info->is_hw) {
 379         dynamicbox_buffer_post_render(info->handle);
 380     } else {
 381         dynamicbox_sync_buffer(info->handle);
 382     }
 383 }
 384
 385 PUBLIC void *dynamicbox_get_evas_object(const char *id, int is_gbar)
 386 {
 387     struct info *info;
 388     Evas_Object *rect;
 389
 390     if (!id) {
 391         ErrPrint("Invalid parameter\n");
 392         return NULL;
 393     }
 394
 395     info = calloc(1, sizeof(*info));
 396     if (!info) {
 397         ErrPrint("Heap: %s\n", strerror(errno));
 398         return NULL;
 399     }
 400
 401     info->id = strdup(id);
 402     if (!info->id) {
 403         ErrPrint("Heap: %s\n", strerror(errno));
 404         free(info);
 405         return NULL;
 406     }
 407
 408     info->is_gbar = is_gbar;
 409
 410     info->ee = ecore_evas_buffer_allocfunc_new(1, 1, alloc_fb, free_fb, info);
 411     if (!info->ee) {
 412         ErrPrint("Failed to create ecore_evas (%dx%d)\n", 1, 1);
 413         free(info->id);
 414         free(info);
 415         return NULL;
 416     }
 417
 418     pre_render_cb(info, NULL, NULL);
 419     ecore_evas_alpha_set(info->ee, EINA_TRUE);
 420     post_render_cb(info, NULL, NULL);
 421
 422     ecore_evas_data_set(info->ee, "dynamic,box,info", info);
 423
 424     ecore_evas_manual_render_set(info->ee, EINA_FALSE);
 425     ecore_evas_resize(info->ee, 1, 1);
 426
 427     info->e = ecore_evas_get(info->ee);
 428     if (!info->e) {
 429         ErrPrint("Failed to get evas\n");
 430         ecore_evas_free(info->ee);
 431         return NULL;
 432     }
 433
 434     evas_event_callback_add(info->e, EVAS_CALLBACK_RENDER_POST, post_render_cb, info);
 435     evas_event_callback_add(info->e, EVAS_CALLBACK_RENDER_PRE, pre_render_cb, info);
 436
 437     rect = evas_object_rectangle_add(info->e);
 438     if (!rect) {
 439         ErrPrint("Failed to create evas_object\n");
 440         ecore_evas_free(info->ee);
 441         return NULL;
 442     }
 443
 444     evas_object_resize(rect, 1, 1);
 445     evas_object_color_set(rect, 0, 0, 0, 0);
 446     return rect;
 447 }
 448
 449 /* End of a file */