2 Simple DirectMedia Layer
3 Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
4 Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
6 This software is provided 'as-is', without any express or implied
7 warranty. In no event will the authors be held liable for any damages
8 arising from the use of this software.
10 Permission is granted to anyone to use this software for any purpose,
11 including commercial applications, and to alter it and redistribute it
12 freely, subject to the following restrictions:
14 1. The origin of this software must not be misrepresented; you must not
15 claim that you wrote the original software. If you use this software
16 in a product, an acknowledgment in the product documentation would be
17 appreciated but is not required.
18 2. Altered source versions must be plainly marked as such, and must not be
19 misrepresented as being the original software.
20 3. This notice may not be removed or altered from any source distribution.
23 #include "../../SDL_internal.h"
25 #if SDL_VIDEO_DRIVER_TIZEN
28 #include "SDL_hints.h"
29 #include "SDL_loadso.h"
31 #include "SDL_tizenvideo.h"
32 #include "SDL_tizentouch.h"
33 #include "SDL_tizenkeyboard.h"
34 #include "SDL_tizenmouse.h"
35 #include "SDL_tizenevents_c.h"
37 #include "SDL_tizenwindow.h"
38 #include "SDL_tizenopengles.h"
40 #include "../../events/SDL_mouse_c.h"
41 #include "../../joystick/tizen/SDL_sysjoystick_c.h"
43 #include "../SDL_egl_c.h"
44 #include "../SDL_vulkan_c.h"
45 #include "../SDL_sysvideo.h"
46 #include "../../events/SDL_windowevents_c.h"
48 #include <Ecore_Ipc.h>
53 ROTATION_TYPE_NORMAL_ROTATION = 0,
54 ROTATION_TYPE_PRE_ROTATION, /* use pre-rotation */
57 #define LOAD_FUNC(NAME) \
58 _this->tizen_pre_rotation_data->NAME = SDL_LoadFunction(_this->tizen_pre_rotation_data->prerotation_dll_handle, #NAME); \
59 if (!_this->tizen_pre_rotation_data->NAME) \
61 SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Could not retrieve pre-rotation function " #NAME); \
66 Ecore_Ipc_Server *ipc = NULL;
68 #define IPC_HEAD(_type) \
69 Ecore_Ipc_Event_Client_##_type *e = event; \
70 if (ecore_ipc_client_server_get(e->client) != ipc) \
71 return ECORE_CALLBACK_PASS_ON
73 void SDL_ExecuteIndicatorProcess()
75 _tizen_init_ecore_ipc();
76 unsigned int childPID = fork();
79 SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] child process : %d", getpid());
80 int ret = execl("/usr/apps/org.tizen.sdl_indicator/bin/sdl_indicator", "/usr/apps/org.tizen.sdl_indicator/bin/sdl_indicator", NULL);
83 SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] Failed indicator process error:%s", strerror(errno));
84 kill(getpid(), SIGKILL);
89 SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] Failed fork");
93 SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] parent process : %d", getpid());
97 void _tizen_ecore_ipc_client_send(int major, int minor, int ref, int ref_to)
99 Eina_List *ipc_clients = ecore_ipc_server_clients_get(ipc);
101 Ecore_Ipc_Client *cl;
102 EINA_LIST_FOREACH(ipc_clients, l, cl)
103 ecore_ipc_client_send(cl, major, minor, ref, ref_to, 0, NULL, 0);
106 static Eina_Bool _cb_client_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
110 SDL_Log("[SDL]_cb_client_add");
111 SDL_Window * window = SDL_GetVideoDevice()->windows;
112 SDL_WindowData *wind = window->driverdata;
113 wind->indicator = SDL_TRUE;
115 int window_w, window_h;
116 ecore_wl_screen_size_get(&window_w, &window_h);
117 _tizen_ecore_ipc_client_send(OP_RESIZE, wind->rotation, window_w, window_h);
119 return ECORE_CALLBACK_DONE;
122 static Eina_Bool _cb_client_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
125 SDL_Log("[SDL]_cb_client_del");
126 Eina_List *ipc_clients = ecore_ipc_server_clients_get(ipc);
128 Ecore_Ipc_Client *cl;
129 EINA_LIST_FOREACH(ipc_clients, l, cl)
131 ecore_ipc_client_del(cl);
134 SDL_Window * window = SDL_GetVideoDevice()->windows;
135 SDL_WindowData *wind = window->driverdata;
136 wind->indicator = SDL_FALSE;
137 return ECORE_CALLBACK_DONE;
140 static Eina_Bool _cb_client_data(void *data, int type EINA_UNUSED, void *event)
144 Ecore_Ipc_Event_Server_Data* epcEvent = (Ecore_Ipc_Event_Server_Data*)event;
145 SDL_Log("[SDL]_cb_client_data: %d -> %d", epcEvent->major, epcEvent->minor);
146 return ECORE_CALLBACK_DONE;
149 int _tizen_init_ecore_ipc()
154 if(!ecore_ipc_init())
155 SDL_Log("[SDL]Fail ecore_ipc");
157 ipc = ecore_ipc_server_add(ECORE_IPC_LOCAL_USER, "sdl_indicator", 0, NULL);
160 ecore_ipc_shutdown();
162 ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_ADD, _cb_client_add, NULL);
163 ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DEL, _cb_client_del, NULL);
164 ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DATA, _cb_client_data, NULL);
170 _tizen_rotation_type_get()
172 static int type = ROTATION_TYPE_PRE_ROTATION;
173 static int checked = 0;
176 if (checked) return type;
178 engine = getenv("SDL_ROTATION");
182 if ((!strcasecmp(engine, "normal")))
183 type = ROTATION_TYPE_NORMAL_ROTATION;
184 else if ((!strcasecmp(engine, "pre_rotation")))
185 type = ROTATION_TYPE_PRE_ROTATION;
187 type = ROTATION_TYPE_PRE_ROTATION;
194 _tizen_PreRotatotion_LoadLibrary(SDL_WindowData *_this, const char *lib_path)
196 void *lib_dll_handle = NULL;
199 if (_this->isLoaded_pre_rotation)
202 _this->tizen_pre_rotation_data = (Tizen_Prerotation_Data *) SDL_calloc(1, sizeof(Tizen_Prerotation_Data));
203 if (!_this->tizen_pre_rotation_data) {
204 return SDL_OutOfMemory();
208 lib_dll_handle = SDL_LoadObject(lib_path);
210 if (!lib_dll_handle) {
211 path = "libwayland-egl.so";
212 lib_dll_handle = SDL_LoadObject(path);
215 _this->tizen_pre_rotation_data->prerotation_dll_handle = lib_dll_handle;
217 if (lib_dll_handle == NULL)
220 LOAD_FUNC(wl_egl_window_set_rotation);
221 LOAD_FUNC(wl_egl_window_get_capabilities);
222 _this->isLoaded_pre_rotation = 1;
228 Tizen_GetWindowWMInfo(_THIS, SDL_Window *window, SDL_SysWMinfo *info)
230 SDL_WindowData *wmdata = (SDL_WindowData *)window->driverdata;
231 info->info.tizen.egl_display = NULL;
232 info->info.tizen.egl_surface = NULL;
233 #if SDL_VIDEO_OPENGL_EGL
236 info->info.tizen.egl_display = (void*)_this->egl_data->egl_display;
238 info->info.tizen.egl_surface = (void*)wmdata->egl_surface;
240 info->subsystem = SDL_SYSWM_TIZEN;
245 Tizen_SetWindowHitTest(SDL_Window *window, SDL_bool enabled)
247 return 0; /* just succeed, the real work is done elsewhere. */
251 Tizen_SetWindowTitle(_THIS, SDL_Window * window)
253 SDL_WindowData *wind = window->driverdata;
254 ecore_wl_window_title_set(wind->window, window->title);
258 Tizen_ShowWindow(_THIS, SDL_Window *window)
260 SDL_WindowData *wind = window->driverdata;
262 if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS) && !wind->indicator)
264 SDL_ExecuteIndicatorProcess();
266 ecore_wl_window_show(wind->window);
270 Tizen_HideWindow(_THIS, SDL_Window *window)
272 SDL_WindowData *wind = window->driverdata;
273 ecore_wl_window_hide(wind->window);
277 Tizen_RaiseWindow(_THIS, SDL_Window *window)
279 SDL_WindowData *wind = window->driverdata;
280 ecore_wl_window_raise(wind->window);
284 Tizen_SetWindowFullscreen(_THIS, SDL_Window *window,
285 SDL_VideoDisplay *_display, SDL_bool fullscreen)
291 Tizen_pre_rotation_set(SDL_WindowData *_this, int rotation)
293 tizen_wl_egl_window_rotation rot;
294 if (!_this->egl_window) return;
298 rot = TIZEN_ROTATION_270;
301 rot = TIZEN_ROTATION_180;
304 rot = TIZEN_ROTATION_90;
307 rot = TIZEN_ROTATION_0;
310 rot = TIZEN_ROTATION_0;
314 _this->tizen_pre_rotation_data->wl_egl_window_set_rotation(_this->egl_window, rot);
318 _tizen_set_window_size(SDL_Window * window, int w, int h)
322 SDL_SetError("Invalid window");
326 SDL_VideoDevice *_this = SDL_GetVideoDevice();
328 SDL_SetError("Video subsystem has not been initialized");
332 if (window->magic != &_this->window_magic) {
337 SDL_InvalidParamError("w");
341 SDL_InvalidParamError("h");
345 /* Make sure we don't exceed any window size limits */
346 if (window->min_w && w < window->min_w)
350 if (window->max_w && w > window->max_w)
354 if (window->min_h && h < window->min_h)
358 if (window->max_h && h > window->max_h)
363 window->windowed.w = w;
364 window->windowed.h = h;
371 _tizen_send_rotation_event(SDL_Window *window, unsigned int angle)
374 SDL_WindowData *wind;
375 wind = window->driverdata;
377 SDL_memset(&event, 0, sizeof(event));
378 event.type = SDL_ROTATEEVENT;
380 if (wind->support_pre_rotation)
381 event.user.data1 = (void*)0;
383 event.user.data1 = (void*)angle;
384 event.user.data2 = (void*)-1;
386 SDL_PushEvent(&event);
391 _tizen_rotation_do(SDL_Window *window, SDL_WindowData* wind, int rotation)
393 int window_w, window_h;
394 if(wind->rotation == 0 || wind->rotation == 180)
395 ecore_wl_window_geometry_get(wind->window, 0, 0, &window_w, &window_h);
397 ecore_wl_window_geometry_get(wind->window, 0, 0, &window_h, &window_w);
399 _tizen_set_window_size(window, window_w, window_h);
401 if(wind->support_pre_rotation)
402 Tizen_pre_rotation_set(wind, rotation);
404 _tizen_send_rotation_event(window, wind->rotation);
405 SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->w, window->h);
410 Tizen_rotate_update(SDL_Window *window)
412 SDL_WindowData *wind = window->driverdata;
416 if (ecore_wl_window_ignore_output_transform_get(wind->window))
422 Ecore_Wl_Output *output = ecore_wl_window_output_find(wind->window);
423 screen_rotation = ecore_wl_output_transform_get(output) * 90;
426 //Set Screen Rotation
427 wind->output_rotation = screen_rotation;
428 if(wind->support_pre_rotation)
429 ecore_wl_window_buffer_transform_set(wind->window, wind->output_rotation / 90);
431 ecore_wl_window_rotation_set(wind->window, wind->rotation);
433 int rotation = (wind->output_rotation + wind->rotation) % 360;
434 _tizen_rotation_do(window, wind, rotation);
438 _tizen_window_orientaiton_hint_callback(void *userdata, const char *name, const char *oldValue, const char *newValue)
441 char orientation_type[4][20] = {"Portrait","LandscapeLeft","PortraitUpsideDown","LandscapeRight"};
442 int checked[4] = {0,};
445 SDL_WindowData *wind = (SDL_WindowData*)userdata;
446 Ecore_Wl_Window *window = wind->window;
448 if (wind->rotation_supported == 0)
451 SDL_assert(SDL_strncmp(name, SDL_HINT_ORIENTATIONS, SDL_strlen(SDL_HINT_ORIENTATIONS)) == 0);
453 if ((oldValue == NULL) && (newValue == NULL))
457 p_str = SDL_strstr(newValue, orientation_type[i]);
459 if (p_str == newValue) {
462 else if (i == 1) rot = 90;
463 else if (i == 2) rot = 180;
464 else if (i == 3) rot = 270;
465 wind->rotation = rot;
486 ecore_wl_window_rotation_preferred_rotation_set(window, wind->rotation);
488 ecore_wl_window_rotation_available_rotations_set(window, (const int*)checked, j);
492 Tizen_rotate_update(Tizen_FindWindow(SDL_GetVideoDevice(), window));
496 _tizen_window_orientation_add_hint(void *data)
498 SDL_WindowData *wind = (SDL_WindowData*)data;
499 if (wind->rotation_supported == 0)
502 SDL_AddHintCallback(SDL_HINT_ORIENTATIONS, _tizen_window_orientaiton_hint_callback, data);
506 _tizen_cb_output_transform(void *data, int type EINA_UNUSED, void *event)
508 SDL_Window * window = SDL_GetVideoDevice()->windows;
509 SDL_WindowData *wind = window->driverdata;
511 if(!wind) return ECORE_CALLBACK_PASS_ON;
513 Ecore_Wl_Event_Output_Transform *ev = event;
514 Ecore_Wl_Output *output;
516 output = ecore_wl_window_output_find(wind->window);
517 if (output != ev->output) return ECORE_CALLBACK_PASS_ON;
519 wind->received_rotation = 1;
522 return ECORE_CALLBACK_PASS_ON;
526 _tizen_cb_ignore_output_transform(void *data, int type EINA_UNUSED, void *event EINA_UNUSED)
528 SDL_Window * window = SDL_GetVideoDevice()->windows;
529 SDL_WindowData *wind = window->driverdata;
531 if(!wind) return ECORE_CALLBACK_PASS_ON;
533 wind->received_rotation = 1;
535 return ECORE_CALLBACK_PASS_ON;
539 _tizen_output_transform_register(SDL_WindowData *wind)
543 Ecore_Wl_Output *output = ecore_wl_window_output_find(wind->window);
544 wind->output_rotation = ecore_wl_output_transform_get(output) * 90;
546 ecore_event_handler_add(ECORE_WL_EVENT_OUTPUT_TRANSFORM,
547 _tizen_cb_output_transform, NULL);
548 ecore_event_handler_add(ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM,
549 _tizen_cb_ignore_output_transform, NULL);
553 Tizen_CreateWindow(_THIS, SDL_Window *window)
555 SDL_VideoData *data = _this->driverdata;
556 SDL_WindowData *wind;
557 Ecore_Wl_Global *global;
558 Eina_Inlist *globals;
560 wind = calloc(1, sizeof * wind);
562 return SDL_OutOfMemory();
565 window->driverdata = wind;
566 window->flags |= SDL_WINDOW_INPUT_FOCUS; /* always has input focus */
568 #if SDL_VIDEO_OPENGL_EGL
569 if (window->flags & SDL_WINDOW_OPENGL) {
570 SDL_GL_LoadLibrary(NULL);
575 if (window->flags & SDL_WINDOW_VULKAN) {
576 if (!_this->vulkan_GetInstanceExtensions) {
577 SDL_SetError("No Vulkan support in video driver");
580 if (_this->vulkan_LoadLibrary(_this, NULL) < 0) {
581 SDL_SetError("Fail to load Vulkan Library");
586 if (window->x == SDL_WINDOWPOS_UNDEFINED) {
589 if (window->y == SDL_WINDOWPOS_UNDEFINED) {
593 if (!(globals = ecore_wl_globals_get()))
595 SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to get wayland globals");
599 wind->window = ecore_wl_window_new(NULL,
600 window->x, window->y, window->w, window->h,
601 ECORE_WL_WINDOW_BUFFER_TYPE_SHM);
603 SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to create wayland window");
606 _tizen_output_transform_register(wind);
608 wind->surface = ecore_wl_window_surface_create(wind->window);
609 if (!wind->surface) {
610 SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to create wayland window surface");
613 ecore_wl_window_type_set(wind->window, ECORE_WL_WINDOW_TYPE_UTILITY);
616 wind->rotation_supported = 0;
617 wind->received_rotation = 0;
619 #if SDL_VIDEO_OPENGL_EGL
620 if (window->flags & SDL_WINDOW_OPENGL) {
622 if(wind->output_rotation == 90 || wind->output_rotation == 270)
623 wind->egl_window = wl_egl_window_create(wind->surface, window->h, window->w);
625 wind->egl_window = wl_egl_window_create(wind->surface, window->w, window->h);
627 /* Create the GLES window surface */
628 wind->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) wind->egl_window);
629 if (wind->egl_surface == EGL_NO_SURFACE) {
630 SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "failed to create a window surface");
634 if (!_this->gl_config.alpha_size) {
635 ecore_wl_window_opaque_region_set(wind->window, window->x, window->y, window->w, window->h);
638 wl_surface_set_opaque_region(wind->surface, NULL);
641 //Support PreRotation
642 wind->support_pre_rotation = 0;
643 if (_tizen_rotation_type_get() && _tizen_PreRotatotion_LoadLibrary(wind, "libwayland-egl.so")) {
644 if (wind->tizen_pre_rotation_data->wl_egl_window_get_capabilities(wind->egl_window) == TIZEN_WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED ) {
645 wind->support_pre_rotation = 1;
650 wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
656 wind->id = ecore_wl_window_id_get(wind->window);
657 eina_hash_add(data->windows, &wind->id, window);
659 Tizen_InitKeyboard(_this);
660 SDL_SetMouseFocus(window);
662 if (window->flags & 0x00008000) {
663 ecore_wl_window_input_region_set(wind->window, -1, -1, 1, 1);
664 ecore_wl_window_focus_skip_set(wind->window, EINA_TRUE);
667 EINA_INLIST_FOREACH(globals, global) {
668 if (!strcmp(global->interface, "tizen_policy_ext")) {
669 wind->rotation_supported = 1;
673 // Add orientaiton hint cb
674 _tizen_window_orientation_add_hint((void*)wind);
676 Tizen_rotate_update(window);
682 Tizen_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered)
684 SDL_WindowData *wind = window->driverdata;
686 SDL_ExecuteIndicatorProcess();
690 Tizen_SetWindowSize(_THIS, SDL_Window *window)
692 SDL_WindowData *wind = window->driverdata;
693 if (!wind->egl_window)
696 if(wind->support_pre_rotation && (wind->rotation==90 || wind->rotation==270))
697 ecore_wl_window_update_size(wind->window, window->h, window->w);
699 ecore_wl_window_update_size(wind->window, window->w, window->h);
701 // TODO : consider to rotation status.
702 #if SDL_VIDEO_OPENGL_EGL
703 if (window->flags & SDL_WINDOW_OPENGL) {
704 if(wind->output_rotation==90 || wind->output_rotation==270)
705 wl_egl_window_resize(wind->egl_window, window->h, window->w, 0, 0);
707 wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
714 Tizen_GetWindowSize(_THIS, SDL_Window *window, int *w, int *h)
716 SDL_WindowData *wind = window->driverdata;
721 if (w) *w = window->w;
722 if (h) *h = window->h;
726 Tizen_SetWindowPosition(_THIS, SDL_Window * window)
728 SDL_WindowData *wind = window->driverdata;
733 // TODO : consider to rotation status.
734 ecore_wl_window_position_set(wind->window, window->x, window->y);
738 Tizen_DestroyWindow(_THIS, SDL_Window *window)
740 SDL_VideoData *data = _this->driverdata;
741 SDL_WindowData *wind = window->driverdata;
744 eina_hash_del(data->windows, &wind->id, window);
745 #if SDL_VIDEO_OPENGL_EGL
746 if (window->flags & SDL_WINDOW_OPENGL) {
747 SDL_EGL_DestroySurface(_this, wind->egl_surface);
748 wl_egl_window_destroy(wind->egl_window);
751 ecore_wl_window_free(wind->window);
755 window->driverdata = NULL;
759 Tizen_FindWindow(_THIS, Ecore_Wl_Window *ewin)
761 SDL_VideoData *data = _this->driverdata;
764 id = ecore_wl_window_id_get(ewin);
765 return (SDL_Window*)eina_hash_find(data->windows, &id);
769 _tizen_cb_event_window_visibility_change(void *data, int type, void *event)
772 Ecore_Wl_Event_Window_Visibility_Change *ev;
777 ew = ecore_wl_window_find(ev->win);
778 window = Tizen_FindWindow(_this, ew);
780 SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SHOWN, 0, 0);
781 SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESTORED, 0, 0);
782 return ECORE_CALLBACK_PASS_ON;
786 _tizen_cb_window_configure(void *data, int type EINA_UNUSED, void *event)
791 SDL_WindowData *wind;
792 Ecore_Wl_Event_Window_Configure *ev;
794 ew = ecore_wl_window_find(ev->win);
795 window = Tizen_FindWindow(_this, ew);
796 wind = window->driverdata;
798 if (wind->rotation_supported == 0){
799 return ECORE_CALLBACK_PASS_ON;
802 return ECORE_CALLBACK_PASS_ON;
806 _tizen_cb_event_window_rotate(void *data, int type EINA_UNUSED, void *event)
809 Ecore_Wl_Event_Window_Rotate *ev;
812 SDL_WindowData *wind;
816 return ECORE_CALLBACK_PASS_ON;
819 ew = ecore_wl_window_find(ev->win);
820 window = Tizen_FindWindow(_this, ew);
821 wind = window->driverdata;
823 if (wind->rotation != ev->angle) {
824 /* set ecore_wayland window rotation */
825 wind->rotation = ev->angle;
826 wind->received_rotation = 1;
829 return ECORE_CALLBACK_PASS_ON;
833 Tizen_InitWindow(_THIS)
835 SDL_VideoData *data = _this->driverdata;
837 data->windows = eina_hash_int32_new(NULL);
839 ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE,
840 _tizen_cb_event_window_visibility_change,_this);
841 ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_ROTATE,
842 _tizen_cb_event_window_rotate,_this);
843 ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_CONFIGURE,
844 _tizen_cb_window_configure,_this);
846 ecore_event_handler_add(ECORE_EVENT_KEY_UP,
847 _tizen_cb_event_keyup_change,_this);
848 ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
849 _tizen_cb_event_keydown_change,_this);
851 ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
852 _tizen_cb_event_mousedown_change,_this);
853 ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
854 _tizen_cb_event_mouseup_change,_this);
855 ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE,
856 _tizen_cb_event_mousemove_change,_this);
857 ecore_event_handler_add(ECORE_WL_EVENT_MOUSE_IN,
858 _tizen_cb_event_mouse_in,_this);
859 ecore_event_handler_add(ECORE_WL_EVENT_MOUSE_OUT,
860 _tizen_cb_event_mouse_out,_this);
862 ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN,
863 _tizen_cb_event_focus_in,_this);
864 ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT,
865 _tizen_cb_event_focus_out,_this);
867 ecore_event_handler_add(ECORE_EVENT_JOYSTICK,
868 _tizen_cb_event_joystick_change,_this);
874 Tizen_DeinitWindow(_THIS)
876 SDL_VideoData *data = _this->driverdata;
878 eina_hash_free(data->windows);
880 #endif /* SDL_VIDEO_DRIVER_TIZEN */
882 /* vi: set ts=4 sw=4 expandtab: */