ecore_evas: introduce ecore_evas_tbm_native_allocfunc_new

tizen display server needs to create ecore_evas by native_surface
and native_display of EGL created in display server if EGL driver
deosn't support tbm.

native_display and native_surface must be not destroyed before
ecore_evas is freed.

Change-Id: Id096c1c233f0f49112171ab4c824fff5aa58b898

diff --git a/src/lib/ecore_evas/Ecore_Evas.h b/src/lib/ecore_evas/Ecore_Evas.h
index 8afc2bd..9f5681d 100755 (executable)
--- a/src/lib/ecore_evas/Ecore_Evas.h
+++ b/src/lib/ecore_evas/Ecore_Evas.h
@@ -1874,6 +1874,14 @@ EAPI const void     *ecore_evas_tbm_pixels_acquire(Ecore_Evas *ee);
 EAPI void            ecore_evas_tbm_pixels_release(Ecore_Evas *ee);
 EAPI void           *ecore_evas_tbm_surface_get(Ecore_Evas *ee);
 EAPI int             ecore_evas_tbm_stride_get(Ecore_Evas *ee);
+
+EAPI Ecore_Evas     *ecore_evas_tbm_native_allocfunc_new(const char *engine,
+                                                         void *native_device,
+                                                         int w,
+                                                         int h,
+                                                         void *(*alloc_func) (void *data, int w, int h),
+                                                         void (*free_func) (void *data, void *native_window),
+                                                         const void *data);
 /* TIZEN_ONLY(20160330): TBM Backend */
 
 /**

diff --git a/src/lib/ecore_evas/ecore_evas.c b/src/lib/ecore_evas/ecore_evas.c
index 3f04850..4d09fde 100644 (file)
--- a/src/lib/ecore_evas/ecore_evas.c
+++ b/src/lib/ecore_evas/ecore_evas.c
@@ -5348,6 +5348,29 @@ ecore_evas_tbm_allocfunc_new(const char *engine, int w, int h,
     return ee;
 }
 
+EAPI Ecore_Evas *
+ecore_evas_tbm_native_allocfunc_new(const char *engine,  void *native_display, int w, int h,
+                             void *(*alloc_func) (void *data, int w, int h),
+                             void (*free_func) (void *data, void *native_window),
+                             const void *data)
+{
+    Ecore_Evas *ee;
+    Ecore_Evas *(*new)(const char*, void *, int, int, Ecore_Evas_Tbm_Alloc_Func, Ecore_Evas_Tbm_Free_Func, const void*);
+
+    Eina_Module *m = NULL;
+    if (!strncmp(engine, "gl_tbm", 6))
+      {
+         m = _ecore_evas_engine_load("tbm");
+      }
+    EINA_SAFETY_ON_NULL_RETURN_VAL(m, NULL);
+
+    new = eina_module_symbol_get(m, "ecore_evas_tbm_native_allocfunc_new_internal");
+    EINA_SAFETY_ON_NULL_RETURN_VAL(new, NULL);
+
+    ee = new(engine, native_display, w, h, alloc_func, free_func, data);
+    return ee;
+}
+
 EAPI const void *
 ecore_evas_tbm_pixels_acquire(Ecore_Evas *ee)
 {

diff --git a/src/modules/ecore_evas/engines/tbm/ecore_evas_tbm.c b/src/modules/ecore_evas/engines/tbm/ecore_evas_tbm.c
index 5cc0dd3..4e44ef9 100644 (file)
--- a/src/modules/ecore_evas/engines/tbm/ecore_evas_tbm.c
+++ b/src/modules/ecore_evas/engines/tbm/ecore_evas_tbm.c
@@ -55,6 +55,8 @@ typedef struct _Ecore_Evas_Engine_Tbm_Data Ecore_Evas_Engine_Tbm_Data;
 
 struct _Ecore_Evas_Engine_Tbm_Data {
    void* tbm_queue;
+   void *native_display;
+   void *native_window;
    tbm_surface_h tbm_surf;
    Eina_Bool ext_tbm_queue;
    void  (*free_func) (void *data, void *tbm_queue);
@@ -241,7 +243,10 @@ _ecore_evas_tbm_free(Ecore_Evas *ee)
    Ecore_Evas_Engine_Tbm_Data *tbm_data = ee->engine.data;
 
    if (tbm_data->tbm_queue && tbm_data->free_func)
-     tbm_data->free_func(tbm_data->data,tbm_data->tbm_queue);
+     tbm_data->free_func(tbm_data->data, tbm_data->tbm_queue);
+   if (tbm_data->native_window && tbm_data->free_func)
+     tbm_data->free_func(tbm_data->data, tbm_data->native_window);
+
    free(tbm_data);
 
    _ecore_evas_tbm_event_unregister();
@@ -287,9 +292,16 @@ _ecore_evas_tbm_resize(Ecore_Evas *ee, int w, int h)
    evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
 
    if (tbm_data->tbm_queue)
-     tbm_data->free_func(tbm_data->data,tbm_data->tbm_queue);
+     {
+        tbm_data->free_func(tbm_data->data, tbm_data->tbm_queue);
+        tbm_data->tbm_queue = tbm_data->alloc_func(tbm_data->data, ee->w, ee->h);
+     }
+   else if (tbm_data->native_window)
+     {
+        tbm_data->free_func(tbm_data->data, tbm_data->native_window);
+        tbm_data->native_window = tbm_data->alloc_func(tbm_data->data, ee->w, ee->h);
+     }
 
-   tbm_data->tbm_queue = tbm_data->alloc_func(tbm_data->data, ee->w, ee->h);
    if (ee->func.fn_resize) ee->func.fn_resize(ee);
 }
 
@@ -496,7 +508,7 @@ _ecore_evas_tbm_render(Ecore_Evas *ee)
            rend |= ee2->engine.func->fn_render(ee2);
         if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
      }
-   if (tbm_data->tbm_queue)
+   if (tbm_data->tbm_queue || tbm_data->native_window)
      {
         updates = evas_render_updates(ee->evas);
      }
@@ -1293,6 +1305,138 @@ ecore_evas_tbm_allocfunc_new_internal(const char *engine, int w, int h,
 }
 
 EAPI Ecore_Evas *
+ecore_evas_tbm_native_allocfunc_new_internal(const char *engine,
+                             void *native_display,
+                             int w, int h,
+                             void *(*alloc_func) (void *data, int w, int h),
+                             void (*free_func) (void *data, void *native_window),
+                             const void *data)
+{
+
+   Ecore_Evas_Engine_Tbm_Data *tbm_data;
+   Ecore_Evas_Interface_Tbm *iface;
+   Ecore_Evas *ee;
+   int rmethod;
+   const char *driver_name;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(alloc_func, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(free_func, NULL);
+
+   if (!strncmp(engine, "gl_tbm", 6))
+     {
+        driver_name = "gl_tbm";
+     }
+   else
+     {
+        ERR("engine name is not gl_tbm");
+        return NULL;
+     }
+
+   rmethod = evas_render_method_lookup(driver_name);
+   EINA_SAFETY_ON_TRUE_RETURN_VAL(rmethod == 0, NULL);
+
+   ee = calloc(1, sizeof(Ecore_Evas));
+   EINA_SAFETY_ON_NULL_RETURN_VAL(ee, NULL);
+
+   tbm_data = calloc(1, sizeof(Ecore_Evas_Engine_Tbm_Data));
+   if (!tbm_data)
+     {
+       free(ee);
+       return NULL;
+     }
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_tbm_engine_func;
+   ee->engine.data = tbm_data;
+   tbm_data->alloc_func = alloc_func;
+   tbm_data->free_func = free_func;
+   tbm_data->data = (void *)data;
+   tbm_data->ext_tbm_queue = EINA_FALSE;
+   tbm_data->native_display = native_display;
+
+   ee->driver = driver_name;
+
+   iface = _ecore_evas_tbm_interface_new();
+   ee->engine.ifaces = eina_list_append(ee->engine.ifaces, iface);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->rotation = 0;
+   ee->visible = 1;
+   ee->w = w;
+   ee->h = h;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+   ee->profile_supported = 1;
+
+   ee->prop.max.w = 0;
+   ee->prop.max.h = 0;
+   ee->prop.layer = 0;
+   ee->prop.focused = EINA_TRUE;
+   ee->prop.borderless = EINA_TRUE;
+   ee->prop.override = EINA_TRUE;
+   ee->prop.maximized = EINA_TRUE;
+   ee->prop.fullscreen = EINA_FALSE;
+   ee->prop.withdrawn = EINA_FALSE;
+   ee->prop.sticky = EINA_FALSE;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+   tbm_data->native_window = tbm_data->alloc_func(tbm_data->data, w, h);
+   ee->prop.window = (Ecore_Window)tbm_data->native_window;
+
+   Evas_Engine_Info_GL_Tbm *einfo = (Evas_Engine_Info_GL_Tbm *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        einfo->info.native_display = tbm_data->native_display;
+        einfo->info.native_window = tbm_data->native_window;
+        einfo->info.destination_alpha = EINA_TRUE;
+        einfo->info.ext_tbm_queue = EINA_FALSE;
+        einfo->info.rotation = 0;
+        einfo->info.depth = 32;
+        einfo->callback.evas = ee->evas;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+
+   evas_key_modifier_add(ee->evas, "Shift");
+   evas_key_modifier_add(ee->evas, "Control");
+   evas_key_modifier_add(ee->evas, "Alt");
+   evas_key_modifier_add(ee->evas, "Meta");
+   evas_key_modifier_add(ee->evas, "Hyper");
+   evas_key_modifier_add(ee->evas, "Super");
+   evas_key_lock_add(ee->evas, "Caps_Lock");
+   evas_key_lock_add(ee->evas, "Num_Lock");
+   evas_key_lock_add(ee->evas, "Scroll_Lock");
+
+   evas_event_feed_mouse_in(ee->evas, 0, NULL);
+
+   _ecore_evas_register(ee);
+
+   evas_event_feed_mouse_in(ee->evas, (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff), NULL);
+
+   _ecore_evas_tbm_event_register(ee);
+
+   return ee;
+
+}
+
+EAPI Ecore_Evas *
 ecore_evas_gl_tbm_new_internal(int w, int h)
 {
     return ecore_evas_tbm_allocfunc_new_internal

diff --git a/src/modules/evas/engines/gl_tbm/Evas_Engine_GL_Tbm.h b/src/modules/evas/engines/gl_tbm/Evas_Engine_GL_Tbm.h
index 05cb3e6..8f8a076 100755 (executable)
--- a/src/modules/evas/engines/gl_tbm/Evas_Engine_GL_Tbm.h
+++ b/src/modules/evas/engines/gl_tbm/Evas_Engine_GL_Tbm.h
@@ -25,6 +25,8 @@ struct _Evas_Engine_Info_GL_Tbm
    struct
      {
         int depth, screen, rotation, edges;
+        void *native_display;
+        void *native_window;
         void *tbm_queue;
         Eina_Bool ext_tbm_queue;
         unsigned int destination_alpha : 1;

diff --git a/src/modules/evas/engines/gl_tbm/evas_engine.h b/src/modules/evas/engines/gl_tbm/evas_engine.h
index 38977c3..2a2615e 100755 (executable)
--- a/src/modules/evas/engines/gl_tbm/evas_engine.h
+++ b/src/modules/evas/engines/gl_tbm/evas_engine.h
@@ -60,6 +60,9 @@ struct _Outbuf
    Evas_Engine_Info_GL_Tbm *info;
    Evas_Engine_GL_Context *gl_context;
 
+   void *native_display;
+   void *native_window;
+
    void *tbm_queue;
    Eina_Bool ext_tbm_queue;
 

diff --git a/src/modules/evas/engines/gl_tbm/evas_tbm_main.c b/src/modules/evas/engines/gl_tbm/evas_tbm_main.c
index bd76cf9..d672ea0 100755 (executable)
--- a/src/modules/evas/engines/gl_tbm/evas_tbm_main.c
+++ b/src/modules/evas/engines/gl_tbm/evas_tbm_main.c
@@ -129,6 +129,8 @@ eng_window_new(Evas_Engine_Info_GL_Tbm *einfo, int w, int h, Render_Output_Swap_
    gw->swap_mode = swap_mode;
    gw->tbm_queue = einfo->info.tbm_queue;
    gw->ext_tbm_queue = einfo->info.ext_tbm_queue;
+   gw->native_display = einfo->info.native_display;
+   gw->native_window = einfo->info.native_window;
    gw->depth = einfo->info.depth;
    gw->alpha = einfo->info.destination_alpha;
    gw->rot = einfo->info.rotation;
@@ -177,14 +179,22 @@ eng_window_new(Evas_Engine_Info_GL_Tbm *einfo, int w, int h, Render_Output_Swap_
     */
 
    setenv("EGL_PLATFORM", "tbm", 1);
-   void* tbm_disp = _tls_display_get();
-   if (tbm_disp == NULL)
+   if (gw->native_display)
      {
-       tbm_disp = tbm_dummy_display_create();
-       _tls_display_set(tbm_disp);
+          gw->egl_disp = eglGetDisplay((EGLNativeDisplayType)gw->native_display);
      }
-   gw->egl_disp = eglGetDisplay((EGLNativeDisplayType)tbm_disp);
-//   gw->egl_disp = eglGetDisplay((EGLNativeDisplayType)tbm_bufmgr_init(-1));
+   else
+     {
+        void* tbm_disp = _tls_display_get();
+        if (tbm_disp == NULL)
+          {
+            tbm_disp = tbm_dummy_display_create();
+            _tls_display_set(tbm_disp);
+          }
+        gw->egl_disp = eglGetDisplay((EGLNativeDisplayType)tbm_disp);
+//        gw->egl_disp = eglGetDisplay((EGLNativeDisplayType)tbm_bufmgr_init(-1));
+     }
+
    if (!gw->egl_disp)
      {
         ERR("eglGetDisplay() fail. code=%#x", eglGetError());
@@ -213,9 +223,19 @@ eng_window_new(Evas_Engine_Info_GL_Tbm *einfo, int w, int h, Render_Output_Swap_
         return NULL;
      }
 
-   gw->egl_surface =
-     eglCreateWindowSurface(gw->egl_disp, gw->egl_config,
-                            (EGLNativeWindowType)gw->tbm_queue, NULL);
+   if (gw->native_window)
+     {
+        gw->egl_surface =
+          eglCreateWindowSurface(gw->egl_disp, gw->egl_config,
+                                 (EGLNativeWindowType)gw->native_window, NULL);
+     }
+   else
+     {
+        gw->egl_surface =
+          eglCreateWindowSurface(gw->egl_disp, gw->egl_config,
+                                 (EGLNativeWindowType)gw->tbm_queue, NULL);
+     }
+
    if (gw->egl_surface == EGL_NO_SURFACE)
      {
         ERR("eglCreateWindowSurface() fail for %p. code=%#x",