X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fvideo%2Ftizen%2FSDL_tizenwindow.c;h=9d0b26d5851eaac576115fb064350bf3d64294eb;hb=35adc16b14e2f2a687ac48e85483098fff746fdc;hp=c1549725eb7ad8e477b23888a525c2cea9f8b7c7;hpb=a967823173c3edd602243e85c2acabb5a64c511d;p=platform%2Fupstream%2FSDL.git

diff --git a/src/video/tizen/SDL_tizenwindow.c b/src/video/tizen/SDL_tizenwindow.c
index c154972..9d0b26d 100755
--- a/src/video/tizen/SDL_tizenwindow.c
+++ b/src/video/tizen/SDL_tizenwindow.c
@@ -28,8 +28,6 @@
 #include "SDL_hints.h"
 #include "SDL_loadso.h"
 
-#include "SDL_tizenindicator.h"
-
 #include "SDL_tizenvideo.h"
 #include "SDL_tizentouch.h"
 #include "SDL_tizenkeyboard.h"
@@ -37,22 +35,161 @@
 #include "SDL_tizenevents_c.h"
 
 #include "SDL_tizenwindow.h"
+#include "SDL_tizenopengles.h"
 
 #include "../../events/SDL_mouse_c.h"
 #include "../../joystick/tizen/SDL_sysjoystick_c.h"
 
 #include "../SDL_egl_c.h"
+#include "../SDL_vulkan_c.h"
 #include "../SDL_sysvideo.h"
 #include "../../events/SDL_windowevents_c.h"
 
+#include <Ecore_Ipc.h>
+#include <unistd.h>
+#include <errno.h>
+
+enum {
+    ROTATION_TYPE_NORMAL_ROTATION = 0,
+    ROTATION_TYPE_PRE_ROTATION,      /* use pre-rotation */
+};
+
 #define LOAD_FUNC(NAME) \
 _this->tizen_pre_rotation_data->NAME = SDL_LoadFunction(_this->tizen_pre_rotation_data->prerotation_dll_handle, #NAME); \
 if (!_this->tizen_pre_rotation_data->NAME) \
 { \
-    SDL_SetError("Could not retrieve pre-rotation function " #NAME); \
+    SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Could not retrieve pre-rotation function " #NAME); \
     return SDL_FALSE; \
 }
 
+/*SDL indicator*/
+Ecore_Ipc_Server *ipc = NULL;
+
+#define IPC_HEAD(_type) \
+   Ecore_Ipc_Event_Client_##_type *e = event; \
+   if (ecore_ipc_client_server_get(e->client) != ipc) \
+     return ECORE_CALLBACK_PASS_ON
+
+void SDL_ExecuteIndicatorProcess()
+{
+    _tizen_init_ecore_ipc();
+    unsigned int childPID = fork();
+    if(childPID == 0)
+    {
+        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] child process : %d", getpid());
+        int ret = execl("/usr/apps/org.tizen.sdl_indicator/bin/sdl_indicator", "/usr/apps/org.tizen.sdl_indicator/bin/sdl_indicator", NULL);
+        if(ret==-1)
+        {
+            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] Failed indicator process error:%s", strerror(errno));
+            kill(getpid(), SIGKILL);
+        }
+    }
+    else if(childPID==-1)
+    {
+        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] Failed fork");
+    }
+    else
+    {
+        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] parent process : %d", getpid());
+    }
+}
+
+void _tizen_ecore_ipc_client_send(int major, int minor, int ref, int ref_to)
+{
+    Eina_List *ipc_clients = ecore_ipc_server_clients_get(ipc);
+    Eina_List *l;
+    Ecore_Ipc_Client *cl;
+    EINA_LIST_FOREACH(ipc_clients, l, cl)
+    ecore_ipc_client_send(cl, major, minor, ref, ref_to, 0, NULL, 0);
+}
+
+static Eina_Bool _cb_client_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
+{
+    IPC_HEAD(Add);
+
+    SDL_Log("[SDL]_cb_client_add");
+    SDL_Window * window = SDL_GetVideoDevice()->windows;
+    SDL_WindowData *wind = window->driverdata;
+    wind->indicator = SDL_TRUE;
+
+    int window_w, window_h;
+    ecore_wl_screen_size_get(&window_w, &window_h);
+    _tizen_ecore_ipc_client_send(OP_RESIZE, wind->rotation, window_w, window_h);
+
+    return ECORE_CALLBACK_DONE;
+}
+
+static Eina_Bool _cb_client_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
+{
+    IPC_HEAD(Del);
+    SDL_Log("[SDL]_cb_client_del");
+    Eina_List *ipc_clients = ecore_ipc_server_clients_get(ipc);
+    Eina_List *l;
+    Ecore_Ipc_Client *cl;
+    EINA_LIST_FOREACH(ipc_clients, l, cl)
+    {
+        ecore_ipc_client_del(cl);
+    }
+
+    SDL_Window * window = SDL_GetVideoDevice()->windows;
+    SDL_WindowData *wind = window->driverdata;
+    wind->indicator = SDL_FALSE;
+    return ECORE_CALLBACK_DONE;
+}
+
+static Eina_Bool _cb_client_data(void *data, int type EINA_UNUSED, void *event)
+{
+    IPC_HEAD(Data);
+
+    Ecore_Ipc_Event_Server_Data* epcEvent = (Ecore_Ipc_Event_Server_Data*)event;
+    SDL_Log("[SDL]_cb_client_data: %d -> %d", epcEvent->major, epcEvent->minor);
+    return ECORE_CALLBACK_DONE;
+}
+
+int _tizen_init_ecore_ipc()
+{
+
+    if(!ipc)
+    {
+        if(!ecore_ipc_init())
+            SDL_Log("[SDL]Fail ecore_ipc");
+
+        ipc = ecore_ipc_server_add(ECORE_IPC_LOCAL_USER, "sdl_indicator", 0, NULL);
+
+        if(!ipc)
+            ecore_ipc_shutdown();
+
+        ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_ADD, _cb_client_add, NULL);
+        ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DEL, _cb_client_del, NULL);
+        ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DATA, _cb_client_data, NULL);
+    }
+    return 0;
+}
+
+static int
+_tizen_rotation_type_get()
+{
+    static int type = ROTATION_TYPE_PRE_ROTATION;
+    static int checked = 0;
+    char *engine = NULL;
+
+    if (checked) return type;
+
+    engine = getenv("SDL_ROTATION");
+
+    if (engine)
+      {
+         if ((!strcasecmp(engine, "normal")))
+            type = ROTATION_TYPE_NORMAL_ROTATION;
+         else if ((!strcasecmp(engine, "pre_rotation")))
+            type = ROTATION_TYPE_PRE_ROTATION;
+         else
+            type = ROTATION_TYPE_PRE_ROTATION;
+      }
+    checked = 1;
+    return type;
+}
+
 int
 _tizen_PreRotatotion_LoadLibrary(SDL_WindowData *_this, const char *lib_path)
 {
@@ -111,13 +248,39 @@ Tizen_SetWindowHitTest(SDL_Window *window, SDL_bool enabled)
 }
 
 void
+Tizen_SetWindowTitle(_THIS, SDL_Window * window)
+{
+    SDL_WindowData *wind = window->driverdata;
+    ecore_wl_window_title_set(wind->window, window->title);
+}
+
+void
 Tizen_ShowWindow(_THIS, SDL_Window *window)
 {
     SDL_WindowData *wind = window->driverdata;
+
+    if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS) && !wind->indicator)
+    {
+        SDL_ExecuteIndicatorProcess();
+    }
     ecore_wl_window_show(wind->window);
 }
 
 void
+Tizen_HideWindow(_THIS, SDL_Window *window)
+{
+    SDL_WindowData *wind = window->driverdata;
+    ecore_wl_window_hide(wind->window);
+}
+
+void
+Tizen_RaiseWindow(_THIS, SDL_Window *window)
+{
+    SDL_WindowData *wind = window->driverdata;
+    ecore_wl_window_raise(wind->window);
+}
+
+void
 Tizen_SetWindowFullscreen(_THIS, SDL_Window *window,
                           SDL_VideoDisplay *_display, SDL_bool fullscreen)
 {
@@ -125,13 +288,12 @@ Tizen_SetWindowFullscreen(_THIS, SDL_Window *window,
 }
 
 void
-_tizen_pre_rotation_set(SDL_WindowData *_this)
+Tizen_pre_rotation_set(SDL_WindowData *_this, int rotation)
 {
     tizen_wl_egl_window_rotation rot;
     if (!_this->egl_window) return;
 
-    SDL_Log("%s with angle %d",__FUNCTION__, _this->rotation);
-    switch (_this->rotation) {
+    switch (rotation) {
          case 90:
             rot = TIZEN_ROTATION_270;
             break;
@@ -149,11 +311,130 @@ _tizen_pre_rotation_set(SDL_WindowData *_this)
             break;
       }
 
-      SDL_SetError("call wl_egl_win_set_rotation with rot %d",rot);
       _this->tizen_pre_rotation_data->wl_egl_window_set_rotation(_this->egl_window, rot);
 }
 
 void
+_tizen_set_window_size(SDL_Window * window, int w, int h)
+{
+    if(!window)
+    {
+        SDL_SetError("Invalid window");
+        return;
+    }
+
+    SDL_VideoDevice *_this = SDL_GetVideoDevice();
+    if (!_this) {
+        SDL_SetError("Video subsystem has not been initialized");
+        return;
+    }
+
+    if (window->magic != &_this->window_magic) {
+        return;
+    }
+
+    if (w <= 0) {
+        SDL_InvalidParamError("w");
+        return;
+    }
+    if (h <= 0) {
+        SDL_InvalidParamError("h");
+        return;
+    }
+
+    /* Make sure we don't exceed any window size limits */
+    if (window->min_w && w < window->min_w)
+    {
+        w = window->min_w;
+    }
+    if (window->max_w && w > window->max_w)
+    {
+        w = window->max_w;
+    }
+    if (window->min_h && h < window->min_h)
+    {
+        h = window->min_h;
+    }
+    if (window->max_h && h > window->max_h)
+    {
+        h = window->max_h;
+    }
+
+    window->windowed.w = w;
+    window->windowed.h = h;
+
+    window->w = w;
+    window->h = h;
+}
+
+void
+_tizen_send_rotation_event(SDL_Window *window, unsigned int angle)
+{
+    SDL_Event event;
+    SDL_WindowData *wind;
+    wind = window->driverdata;
+
+    SDL_memset(&event, 0, sizeof(event));
+    event.type = SDL_ROTATEEVENT;
+    event.user.code = 0;
+    if (wind->support_pre_rotation)
+        event.user.data1 = (void*)0;
+    else
+        event.user.data1 = (void*)angle;
+    event.user.data2 = (void*)-1;
+
+    SDL_PushEvent(&event);
+    return;
+}
+
+void
+_tizen_rotation_do(SDL_Window *window, SDL_WindowData* wind, int rotation)
+{
+    int window_w, window_h;
+    if(wind->rotation == 0 || wind->rotation == 180)
+        ecore_wl_window_geometry_get(wind->window, 0, 0, &window_w, &window_h);
+    else
+        ecore_wl_window_geometry_get(wind->window, 0, 0, &window_h, &window_w);
+
+    _tizen_set_window_size(window, window_w, window_h);
+
+    if(wind->support_pre_rotation)
+        Tizen_pre_rotation_set(wind, rotation);
+
+    _tizen_send_rotation_event(window, wind->rotation);
+    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->w, window->h);
+
+}
+
+void
+Tizen_rotate_update(SDL_Window *window)
+{
+    SDL_WindowData *wind = window->driverdata;
+    if(!wind) return;
+
+    int screen_rotation;
+    if (ecore_wl_window_ignore_output_transform_get(wind->window))
+    {
+        screen_rotation = 0;
+    }
+    else
+    {
+        Ecore_Wl_Output *output = ecore_wl_window_output_find(wind->window);
+        screen_rotation = ecore_wl_output_transform_get(output) * 90;
+    }
+
+    //Set Screen Rotation
+    wind->output_rotation = screen_rotation;
+    if(wind->support_pre_rotation)
+        ecore_wl_window_buffer_transform_set(wind->window, wind->output_rotation / 90);
+
+    ecore_wl_window_rotation_set(wind->window, wind->rotation);
+
+    int rotation = (wind->output_rotation + wind->rotation) % 360;
+    _tizen_rotation_do(window, wind, rotation);
+}
+
+void
 _tizen_window_orientaiton_hint_callback(void *userdata, const char *name, const char *oldValue, const char *newValue)
 {
     char *p_str = NULL;
@@ -164,15 +445,13 @@ _tizen_window_orientaiton_hint_callback(void *userdata, const char *name, const
     SDL_WindowData *wind = (SDL_WindowData*)userdata;
     Ecore_Wl_Window *window = wind->window;
 
-    if (wind->rotation_supported == 0) {
+    if (wind->rotation_supported == 0)
         return;
-    }
 
     SDL_assert(SDL_strncmp(name, SDL_HINT_ORIENTATIONS, SDL_strlen(SDL_HINT_ORIENTATIONS)) == 0);
 
-    if ((oldValue == NULL) && (newValue == NULL)) {
+    if ((oldValue == NULL) && (newValue == NULL))
         return;
-    }
 
     for (i=0;i<4;i++) {
         p_str = SDL_strstr(newValue, orientation_type[i]);
@@ -188,19 +467,15 @@ _tizen_window_orientaiton_hint_callback(void *userdata, const char *name, const
 
             if (i == 0) {
                 checked[j] = 0;
-                SDL_Log("SDL  %s: avaiable rotation: 0", __FUNCTION__);
             }
             else if (i == 1) {
                 checked[j] = 90;
-                SDL_Log("SDL %s: avaiable rotation: 90", __FUNCTION__);
             }
             else if (i == 2) {
                 checked[j] = 180;
-                SDL_Log("SDL %s: avaiable rotation: 180", __FUNCTION__);
             }
             else if (i == 3) {
                 checked[j] = 270;
-                SDL_Log("SDL %s: avaiable rotation: 270", __FUNCTION__);
             }
             j++;
         }
@@ -208,28 +483,72 @@ _tizen_window_orientaiton_hint_callback(void *userdata, const char *name, const
 
     if (j > 0) {
         if (j == 1) {
-            ecore_wl_window_rotation_preferred_rotation_set(window,wind->rotation);
-            SDL_Log("SDL %s: support pre_rotation %d", __FUNCTION__,wind->support_pre_rotation);
-            if (wind->support_pre_rotation) {
-                SDL_Log("SDL %s: set pre rotation %d", __FUNCTION__,wind->rotation);
-                _tizen_pre_rotation_set(wind);
-            }
+            ecore_wl_window_rotation_preferred_rotation_set(window, wind->rotation);
+        }else {
+            ecore_wl_window_rotation_available_rotations_set(window, (const int*)checked, j);
         }
-        ecore_wl_window_rotation_available_rotations_set(window, (const int*)checked, j);
     }
+
+    Tizen_rotate_update(Tizen_FindWindow(SDL_GetVideoDevice(), window));
 }
 
 void
 _tizen_window_orientation_add_hint(void *data)
 {
     SDL_WindowData *wind = (SDL_WindowData*)data;
-    if (wind->rotation_supported == 0) {
+    if (wind->rotation_supported == 0)
         return;
-    }
 
     SDL_AddHintCallback(SDL_HINT_ORIENTATIONS, _tizen_window_orientaiton_hint_callback, data);
 }
 
+static Eina_Bool
+_tizen_cb_output_transform(void *data, int type EINA_UNUSED, void *event)
+{
+    SDL_Window * window = SDL_GetVideoDevice()->windows;
+    SDL_WindowData *wind = window->driverdata;
+
+    if(!wind) return ECORE_CALLBACK_PASS_ON;
+
+    Ecore_Wl_Event_Output_Transform *ev = event;
+    Ecore_Wl_Output *output;
+
+    output = ecore_wl_window_output_find(wind->window);
+    if (output != ev->output) return ECORE_CALLBACK_PASS_ON;
+
+    wind->received_rotation = 1;
+
+
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_tizen_cb_ignore_output_transform(void *data, int type EINA_UNUSED, void *event EINA_UNUSED)
+{
+    SDL_Window * window = SDL_GetVideoDevice()->windows;
+    SDL_WindowData *wind = window->driverdata;
+
+    if(!wind) return ECORE_CALLBACK_PASS_ON;
+
+    wind->received_rotation = 1;
+
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+void
+_tizen_output_transform_register(SDL_WindowData *wind)
+{
+    if(!wind) return;
+
+    Ecore_Wl_Output *output = ecore_wl_window_output_find(wind->window);
+    wind->output_rotation = ecore_wl_output_transform_get(output) * 90;
+
+    ecore_event_handler_add(ECORE_WL_EVENT_OUTPUT_TRANSFORM,
+                             _tizen_cb_output_transform, NULL);
+    ecore_event_handler_add(ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM,
+                             _tizen_cb_ignore_output_transform, NULL);
+}
+
 int
 Tizen_CreateWindow(_THIS, SDL_Window *window)
 {
@@ -252,6 +571,18 @@ Tizen_CreateWindow(_THIS, SDL_Window *window)
     }
 #endif
 
+#if SDL_VIDEO_VULKAN
+    if (window->flags & SDL_WINDOW_VULKAN) {
+        if (!_this->vulkan_GetInstanceExtensions) {
+            SDL_SetError("No Vulkan support in video driver");
+        }
+
+        if (_this->vulkan_LoadLibrary(_this, NULL) < 0) {
+            SDL_SetError("Fail to load Vulkan Library");
+        }
+    }
+#endif
+
     if (window->x == SDL_WINDOWPOS_UNDEFINED) {
         window->x = 0;
     }
@@ -261,44 +592,64 @@ Tizen_CreateWindow(_THIS, SDL_Window *window)
 
     if (!(globals = ecore_wl_globals_get()))
       {
-         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get wayland globals");
+         SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to get wayland globals");
          return -1;
       }
 
     wind->window = ecore_wl_window_new(NULL,
                                        window->x, window->y, window->w, window->h,
                                        ECORE_WL_WINDOW_BUFFER_TYPE_SHM);
+    if (!wind->window) {
+        SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to create wayland window");
+        return -1;
+    }
+    _tizen_output_transform_register(wind);
+
     wind->surface = ecore_wl_window_surface_create(wind->window);
+    if (!wind->surface) {
+        SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to create wayland window surface");
+        return -1;
+    }
+    ecore_wl_window_type_set(wind->window, ECORE_WL_WINDOW_TYPE_UTILITY);
+
     wind->rotation = 0;
     wind->rotation_supported = 0;
     wind->received_rotation = 0;
-    ecore_wl_window_opaque_region_set(wind->window, window->x, window->y, window->w, window->h);
 
 #if SDL_VIDEO_OPENGL_EGL
     if (window->flags & SDL_WINDOW_OPENGL) {
-        wind->egl_window = wl_egl_window_create(ecore_wl_window_surface_get(wind->window), window->w, window->h);
+
+        if(wind->output_rotation == 90 || wind->output_rotation == 270)
+            wind->egl_window = wl_egl_window_create(wind->surface, window->h, window->w);
+        else
+            wind->egl_window = wl_egl_window_create(wind->surface, window->w, window->h);
 
         /* Create the GLES window surface */
         wind->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) wind->egl_window);
         if (wind->egl_surface == EGL_NO_SURFACE) {
-            SDL_SetError("failed to create a window surface");
+            SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "failed to create a window surface");
             return -1;
         }
 
+        if (!_this->gl_config.alpha_size) {
+            ecore_wl_window_opaque_region_set(wind->window, window->x, window->y, window->w, window->h);
+        }
+        else {
+            wl_surface_set_opaque_region(wind->surface, NULL);
+        }
+
         //Support PreRotation
         wind->support_pre_rotation = 0;
-        if (_tizen_PreRotatotion_LoadLibrary(wind, "libwayland-egl.so")) {
+        if (_tizen_rotation_type_get() && _tizen_PreRotatotion_LoadLibrary(wind, "libwayland-egl.so")) {
             if (wind->tizen_pre_rotation_data->wl_egl_window_get_capabilities(wind->egl_window) == TIZEN_WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED ) {
                 wind->support_pre_rotation = 1;
-                SDL_Log("Can support PreRotation");
-            }
-            else {
-                SDL_Log("can not support PreRotation !!");
             }
         }
-        else {
-            SDL_Log("can not support PreRotation !!");
+        else
+        {
+            wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
         }
+
     }
 #endif
 
@@ -309,9 +660,6 @@ Tizen_CreateWindow(_THIS, SDL_Window *window)
     SDL_SetMouseFocus(window);
 
     if (window->flags & 0x00008000) {
-        SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "---------------------------------------");
-        SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "[SDL] touch bypass setting is done!\n");
-        SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "---------------------------------------");
         ecore_wl_window_input_region_set(wind->window, -1, -1, 1, 1);
         ecore_wl_window_focus_skip_set(wind->window, EINA_TRUE);
     }
@@ -319,51 +667,47 @@ Tizen_CreateWindow(_THIS, SDL_Window *window)
     EINA_INLIST_FOREACH(globals, global) {
          if (!strcmp(global->interface, "tizen_policy_ext")) {
               wind->rotation_supported = 1;
-              SDL_Log("SDL can support rotation in this device!!!!!!!!!!!");
               break;
            }
       }
     // Add orientaiton hint cb
     _tizen_window_orientation_add_hint((void*)wind);
+
+    Tizen_rotate_update(window);
+
     return 0;
 }
 
 void
-_tizen_egl_window_resize(SDL_Window *window)
+Tizen_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered)
 {
     SDL_WindowData *wind = window->driverdata;
-    if (!wind->egl_window) {
-        return;
-    }
-
-    // TODO : consider to rotation status.
-#if SDL_VIDEO_OPENGL_EGL
-    if (window->flags & SDL_WINDOW_OPENGL) {
-        // TODO : if window size is not FULL, we need the code about Non FullSize Window.
-        int aw, ah;
-        wl_egl_window_get_attached_size(wind->egl_window, &aw, &ah);
-        wl_egl_window_resize(wind->egl_window, aw, ah, 0, 0);
-    }
-#endif
-
+    if(!wind->indicator)
+        SDL_ExecuteIndicatorProcess();
 }
 
 void
-_tizen_setwindowsize(SDL_Window *window)
+Tizen_SetWindowSize(_THIS, SDL_Window *window)
 {
     SDL_WindowData *wind = window->driverdata;
-    if (!wind->window) {
+    if (!wind->egl_window)
         return;
+
+    if(wind->support_pre_rotation && (wind->rotation==90 || wind->rotation==270))
+        ecore_wl_window_update_size(wind->window, window->h, window->w);
+    else
+        ecore_wl_window_update_size(wind->window, window->w, window->h);
+
+    // TODO : consider to rotation status.
+    #if SDL_VIDEO_OPENGL_EGL
+    if (window->flags & SDL_WINDOW_OPENGL) {
+        if(wind->output_rotation==90 || wind->output_rotation==270)
+            wl_egl_window_resize(wind->egl_window, window->h, window->w, 0, 0);
+        else
+            wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
     }
-    ecore_wl_window_update_size(wind->window, window->w, window->h);
-}
+    #endif
 
-void
-Tizen_SetWindowSize(_THIS, SDL_Window *window)
-{
-   SDL_Log("[SDL_Size] Tizen_SetWindowSize");
-//    _tizen_setwindowsize(window);
-//    _tizen_egl_window_resize(window);
 }
 
 void
@@ -433,8 +777,6 @@ _tizen_cb_event_window_visibility_change(void *data, int type, void *event)
     ew = ecore_wl_window_find(ev->win);
     window = Tizen_FindWindow(_this, ew);
 
-    SDL_Log( "visibility window: %p, ecore_wl_window: %p\n", window, ew);
-
     SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SHOWN, 0, 0);
     SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESTORED, 0, 0);
     return ECORE_CALLBACK_PASS_ON;
@@ -456,44 +798,8 @@ _tizen_cb_window_configure(void *data, int type EINA_UNUSED, void *event)
    if (wind->rotation_supported == 0){
       return ECORE_CALLBACK_PASS_ON;
    }
-/*
-   int nx = 0, ny = 0, nw = 0, nh = 0;
-  SDL_Log( "configure notify window: %p, ecore_wl_window: %p\n", window, ew);
-
-   ecore_wl_window_geometry_get(ew, &nx, &ny, &nw, &nh);
-   if (nw < 1) nw = 1;
-   if (nh < 1) nh = 1;
-   
-   SDL_Log("[SDL_Size] * _tizen_cb_window_configure :: w->w:%d, w->h:%d, nw:%d, nh:%d", window->w, window->h, nw, nh);
-   if ((window->x != nx) || (window->y != ny))
-     ecore_wl_window_position_set(ew, nx, ny);
-
-   if ((window->w != nw) || (window->h != nh)) {
-     _tizen_setwindowsize(window);
-   }
-   */
-   return ECORE_CALLBACK_PASS_ON;
-}
-
 
-void
-_tizen_send_rotation_event(SDL_Window *window, unsigned int angle)
-{
-    SDL_Event event;
-    SDL_WindowData *wind;
-    wind = window->driverdata;
-
-    SDL_memset(&event, 0, sizeof(event));
-    event.type = SDL_ROTATEEVENT;
-    event.user.code = 0;
-    if (wind->support_pre_rotation)
-        event.user.data1 = (void*)0;
-    else
-        event.user.data1 = (void*)angle;
-    event.user.data2 = (void*)-1;
-
-    SDL_PushEvent(&event);
-    return;
+   return ECORE_CALLBACK_PASS_ON;
 }
 
 Eina_Bool
@@ -517,39 +823,9 @@ _tizen_cb_event_window_rotate(void *data, int type EINA_UNUSED, void *event)
     if (wind->rotation != ev->angle) {
         /* set ecore_wayland window rotation */
         wind->rotation = ev->angle;
-        ecore_wl_window_rotation_set(ew, ev->angle);
-
-        if(wind->support_pre_rotation) {
-            _tizen_pre_rotation_set(wind);
-
-            int aw, ah;
-            wl_egl_window_get_attached_size(wind->egl_window, &aw, &ah);
-            wl_egl_window_resize(wind->egl_window, aw, ah, 0, 0);
-
-            SDL_Log("[SDL_Size] * _tizen_cb_event_window_rotate aw ah : %d, %d", aw, ah);
-
-            if(wind->rotation == 90 || wind->rotation == 270) {
-                SDL_SetWindowSize(window, ah, aw);
-                window->w = ah;//for Fullscreen
-                window->h = aw;
-            } else {
-                SDL_SetWindowSize(window, aw, ah);//->call wl_egl_window_resize()
-                window->w = aw;//for Fullscreen
-                window->h = ah;
-            }
-            SDL_Log("[SDL_Size] * _tizen_cb_event_window_rotate aw ah : %d, %d", window->w, window->h);
-    }
-
-        // Send Rotation Event
-        _tizen_send_rotation_event(window, ev->angle);
-        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->w, window->h);
+        wind->received_rotation = 1;
     }
 
-    wind->received_rotation = 1;
-    const char* hint = SDL_GetHint(SDL_HINT_ORIENTATIONS);
-    if(hint && *hint != '\0')
-        Tizen_IndicatorProcessEvent(_this->current_glwin, wind->rotation);
-
     return ECORE_CALLBACK_PASS_ON;
 }
 
@@ -562,32 +838,34 @@ Tizen_InitWindow(_THIS)
 
     ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE,
                         _tizen_cb_event_window_visibility_change,_this);
+    ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_ROTATE,
+                        _tizen_cb_event_window_rotate,_this);
+    ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_CONFIGURE,
+                        _tizen_cb_window_configure,_this);
+
     ecore_event_handler_add(ECORE_EVENT_KEY_UP,
                         _tizen_cb_event_keyup_change,_this);
     ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
                         _tizen_cb_event_keydown_change,_this);
+
     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
                         _tizen_cb_event_mousedown_change,_this);
     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
                         _tizen_cb_event_mouseup_change,_this);
     ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE,
                         _tizen_cb_event_mousemove_change,_this);
-    ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_ROTATE,
-                        _tizen_cb_event_window_rotate,_this);
-    ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_CONFIGURE,
-                        _tizen_cb_window_configure,_this);
-    ecore_event_handler_add(ECORE_EVENT_JOYSTICK,
-                        _tizen_cb_event_joystick_change,_this);
-    ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN,
-                        _tizen_cb_event_focus_in,_this);
-    ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT,
-                        _tizen_cb_event_focus_out,_this);
     ecore_event_handler_add(ECORE_WL_EVENT_MOUSE_IN,
                         _tizen_cb_event_mouse_in,_this);
     ecore_event_handler_add(ECORE_WL_EVENT_MOUSE_OUT,
                         _tizen_cb_event_mouse_out,_this);
 
-    data->current_thread = SDL_GetThreadID(0);
+    ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN,
+                        _tizen_cb_event_focus_in,_this);
+    ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT,
+                        _tizen_cb_event_focus_out,_this);
+
+    ecore_event_handler_add(ECORE_EVENT_JOYSTICK,
+                        _tizen_cb_event_joystick_change,_this);
 
     return 0;
 }