X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fvideo%2Ftizen%2FSDL_tizenwindow.c;h=9d0b26d5851eaac576115fb064350bf3d64294eb;hb=35adc16b14e2f2a687ac48e85483098fff746fdc;hp=cecdca5185f18eb1c8deac4749ce8cbd54caa605;hpb=0958f98c448f8a06b92c1e2bbecb959dd1a81a1b;p=platform%2Fupstream%2FSDL.git diff --git a/src/video/tizen/SDL_tizenwindow.c b/src/video/tizen/SDL_tizenwindow.c old mode 100644 new mode 100755 index cecdca5..9d0b26d --- a/src/video/tizen/SDL_tizenwindow.c +++ b/src/video/tizen/SDL_tizenwindow.c @@ -24,21 +24,205 @@ #if SDL_VIDEO_DRIVER_TIZEN -#include "../SDL_sysvideo.h" -#include "../../events/SDL_windowevents_c.h" -#include "../SDL_egl_c.h" -#include "SDL_tizenwindow.h" +#include "SDL_log.h" +#include "SDL_hints.h" +#include "SDL_loadso.h" + #include "SDL_tizenvideo.h" #include "SDL_tizentouch.h" #include "SDL_tizenkeyboard.h" - #include "SDL_tizenmouse.h" #include "SDL_tizenevents_c.h" -#include "SDL_log.h" -#include "SDL_hints.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 +#include +#include + +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_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) +{ + void *lib_dll_handle = NULL; + char *path = NULL; + + if (_this->isLoaded_pre_rotation) + return SDL_TRUE; + + _this->tizen_pre_rotation_data = (Tizen_Prerotation_Data *) SDL_calloc(1, sizeof(Tizen_Prerotation_Data)); + if (!_this->tizen_pre_rotation_data) { + return SDL_OutOfMemory(); + } + + if (!lib_path) + lib_dll_handle = SDL_LoadObject(lib_path); -#include + if (!lib_dll_handle) { + path = "libwayland-egl.so"; + lib_dll_handle = SDL_LoadObject(path); + } + + _this->tizen_pre_rotation_data->prerotation_dll_handle = lib_dll_handle; + + if (lib_dll_handle == NULL) + return SDL_FALSE; + + LOAD_FUNC(wl_egl_window_set_rotation); + LOAD_FUNC(wl_egl_window_get_capabilities); + _this->isLoaded_pre_rotation = 1; + + return SDL_TRUE; +} SDL_bool Tizen_GetWindowWMInfo(_THIS, SDL_Window *window, SDL_SysWMinfo *info) @@ -64,20 +248,193 @@ 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) { /*DO NOTHING*/ } -static void +void +Tizen_pre_rotation_set(SDL_WindowData *_this, int rotation) +{ + tizen_wl_egl_window_rotation rot; + if (!_this->egl_window) return; + + switch (rotation) { + case 90: + rot = TIZEN_ROTATION_270; + break; + case 180: + rot = TIZEN_ROTATION_180; + break; + case 270: + rot = TIZEN_ROTATION_90; + break; + case 0: + rot = TIZEN_ROTATION_0; + break; + default: + rot = TIZEN_ROTATION_0; + break; + } + + _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; @@ -89,15 +446,12 @@ _tizen_window_orientaiton_hint_callback(void *userdata, const char *name, const Ecore_Wl_Window *window = wind->window; 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]); @@ -113,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++; } @@ -133,23 +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); + 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)); } -static void +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) { @@ -164,6 +563,7 @@ Tizen_CreateWindow(_THIS, SDL_Window *window) } window->driverdata = wind; + window->flags |= SDL_WINDOW_INPUT_FOCUS; /* always has input focus */ #if SDL_VIDEO_OPENGL_EGL if (window->flags & SDL_WINDOW_OPENGL) { @@ -171,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; } @@ -180,29 +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_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; + } + } + else + { + wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0); + } + } #endif @@ -210,91 +657,71 @@ Tizen_CreateWindow(_THIS, SDL_Window *window) eina_hash_add(data->windows, &wind->id, window); Tizen_InitKeyboard(_this); + SDL_SetMouseFocus(window); - if (window->flags & SDL_WINDOW_MOUSE_UNFOCUS) { - SDL_Log("SDL_WINDOW_MOUSE_UNFOCUS is set. Mouse event will be passed the focused window."); + if (window->flags & 0x00008000) { ecore_wl_window_input_region_set(wind->window, -1, -1, 1, 1); - } - else { - SDL_SetMouseFocus(window); - } - - if (window->flags & SDL_WINDOW_INPUT_UNFOCUS) { - SDL_Log("SDL_WINDOW_INPUT_UNFOCUS is set. Key event will be passed the focused window."); ecore_wl_window_focus_skip_set(wind->window, EINA_TRUE); } 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_setwindowsize(SDL_Window *window, int update_egl) +Tizen_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered) { SDL_WindowData *wind = window->driverdata; - if (!wind->window) - { + if(!wind->indicator) + SDL_ExecuteIndicatorProcess(); +} + +void +Tizen_SetWindowSize(_THIS, SDL_Window *window) +{ + 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) && (update_egl == 1)) { - int aw, ah, dx = 0, dy = 0; + 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); - if ((wind->rotation == 90) || (wind->rotation == 270)) - wl_egl_window_get_attached_size(wind->egl_window, &ah, &aw); + // 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_get_attached_size(wind->egl_window, &aw, &ah); - - SDL_Log("SDL %s:wl_egl_window_get_attached_size:rot(%i)%ix%i",__FUNCTION__,wind->rotation,aw,ah); - - // TODO : if window size is not FULL, we need the code about Non FullSize Window. - wl_egl_window_resize(wind->egl_window, window->w, window->h, dx, dy); + wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0); } -#endif - ecore_wl_window_update_size(wind->window, window->w, window->h); -} + #endif -void -Tizen_SetWindowSize(_THIS, SDL_Window *window) -{ - _tizen_setwindowsize(window, 1); } void Tizen_GetWindowSize(_THIS, SDL_Window *window, int *w, int *h) { SDL_WindowData *wind = window->driverdata; - int tmp_w, tmp_h; if (!wind->window) { return; } - tmp_w = window->w; - tmp_h = window->h; - if (wind->rotation == 90 || wind->rotation == 270) { - tmp_w = window->h; - tmp_h = window->w; - } - - if (w) { - *w = tmp_w; - } - if (h) { - *h = tmp_h; - } + if (w) *w = window->w; + if (h) *h = window->h; } - void Tizen_SetWindowPosition(_THIS, SDL_Window * window) { @@ -328,8 +755,8 @@ Tizen_DestroyWindow(_THIS, SDL_Window *window) window->driverdata = NULL; } -static SDL_Window* -_tizen_find_window(_THIS, Ecore_Wl_Window *ewin) +SDL_Window* +Tizen_FindWindow(_THIS, Ecore_Wl_Window *ewin) { SDL_VideoData *data = _this->driverdata; int id; @@ -338,7 +765,7 @@ _tizen_find_window(_THIS, Ecore_Wl_Window *ewin) return (SDL_Window*)eina_hash_find(data->windows, &id); } -static Eina_Bool +Eina_Bool _tizen_cb_event_window_visibility_change(void *data, int type, void *event) { _THIS = data; @@ -348,16 +775,14 @@ _tizen_cb_event_window_visibility_change(void *data, int type, void *event) ev = event; ew = ecore_wl_window_find(ev->win); - window = _tizen_find_window(_this, ew); - - SDL_Log( "visibility window: %p, ecore_wl_window: %p\n", window, ew); + window = Tizen_FindWindow(_this, ew); SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SHOWN, 0, 0); SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESTORED, 0, 0); return ECORE_CALLBACK_PASS_ON; } -static Eina_Bool +Eina_Bool _tizen_cb_window_configure(void *data, int type EINA_UNUSED, void *event) { _THIS = data; @@ -365,35 +790,19 @@ _tizen_cb_window_configure(void *data, int type EINA_UNUSED, void *event) SDL_Window *window; SDL_WindowData *wind; Ecore_Wl_Event_Window_Configure *ev; - int nx = 0, ny = 0, nw = 0, nh = 0; ev = event; ew = ecore_wl_window_find(ev->win); - window = _tizen_find_window(_this, ew); + window = Tizen_FindWindow(_this, ew); wind = window->driverdata; if (wind->rotation_supported == 0){ return ECORE_CALLBACK_PASS_ON; } - 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; - - if ((window->x != nx) || (window->y != ny)) - ecore_wl_window_position_set(ew, nx, ny); - - if ((window->w != nw) || (window->h != nh)) { - window->w = nw; - window->h = nh; - - _tizen_setwindowsize(window, 0); - } return ECORE_CALLBACK_PASS_ON; } -static Eina_Bool +Eina_Bool _tizen_cb_event_window_rotate(void *data, int type EINA_UNUSED, void *event) { _THIS = data; @@ -408,20 +817,15 @@ _tizen_cb_event_window_rotate(void *data, int type EINA_UNUSED, void *event) } ew = ecore_wl_window_find(ev->win); - window = _tizen_find_window(_this, ew); + window = Tizen_FindWindow(_this, ew); wind = window->driverdata; if (wind->rotation != ev->angle) { /* set ecore_wayland window rotation */ wind->rotation = ev->angle; - ecore_wl_window_rotation_set(ew, ev->angle); - _tizen_setwindowsize(window, 1); - if (wind->rotation == 0 || wind->rotation == 180) - SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->w, window->h); - else if (wind->rotation == 90 || wind->rotation == 270) - SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->h, window->w); + wind->received_rotation = 1; } - wind->received_rotation = 1; + return ECORE_CALLBACK_PASS_ON; } @@ -434,20 +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_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); + + 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; }