src/video/tizen/SDL_tizenwindow.c

   1 /*
   2   Simple DirectMedia Layer
   3   Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
   4   Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   5
   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.
   9
  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:
  13
  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.
  21 */
  22
  23 #include "../../SDL_internal.h"
  24
  25 #if SDL_VIDEO_DRIVER_TIZEN
  26
  27 #include "SDL_log.h"
  28 #include "SDL_hints.h"
  29 #include "SDL_loadso.h"
  30
  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"
  36
  37 #include "SDL_tizenwindow.h"
  38 #include "SDL_tizenopengles.h"
  39
  40 #include "../../events/SDL_mouse_c.h"
  41 #include "../../joystick/tizen/SDL_sysjoystick_c.h"
  42
  43 #include "../SDL_egl_c.h"
  44 #include "../SDL_vulkan_c.h"
  45 #include "../SDL_sysvideo.h"
  46 #include "../../events/SDL_windowevents_c.h"
  47
  48 #include <Ecore_Ipc.h>
  49 #include <unistd.h>
  50 #include <errno.h>
  51
  52 enum {
  53     ROTATION_TYPE_NORMAL_ROTATION = 0,
  54     ROTATION_TYPE_PRE_ROTATION,      /* use pre-rotation */
  55 };
  56
  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) \
  60 { \
  61     SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Could not retrieve pre-rotation function " #NAME); \
  62     return SDL_FALSE; \
  63 }
  64
  65 /*SDL indicator*/
  66
  67
  68
  69 Ecore_Ipc_Server *ipc = NULL;
  70
  71 #define IPC_HEAD(_type) \
  72    Ecore_Ipc_Event_Client_##_type *e = event; \
  73    if (ecore_ipc_client_server_get(e->client) != ipc) \
  74      return ECORE_CALLBACK_PASS_ON
  75
  76 void SDL_ExecuteIndicatorProcess()
  77 {
  78     _tizen_init_ecore_ipc();
  79     unsigned int childPID = fork();
  80     if(childPID == 0)
  81     {
  82         SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] child process : %d", getpid());
  83         int ret = execl("/usr/apps/org.tizen.sdl_indicator/bin/sdl_indicator", "/usr/apps/org.tizen.sdl_indicator/bin/sdl_indicator", NULL);
  84         if(ret==-1)
  85         {
  86             SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] Failed indicator process error:%s", strerror(errno));
  87             kill(getpid(), SIGKILL);
  88         }
  89     }
  90     else if(childPID==-1)
  91     {
  92         SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] Failed fork");
  93     }
  94     else
  95     {
  96         SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "[SDL] parent process : %d", getpid());
  97     }
  98 }
  99
 100 void _tizen_ecore_ipc_client_send(int major, int minor, int ref, int ref_to)
 101 {
 102     Eina_List *ipc_clients = ecore_ipc_server_clients_get(ipc);
 103     Eina_List *l;
 104     Ecore_Ipc_Client *cl;
 105     EINA_LIST_FOREACH(ipc_clients, l, cl)
 106     ecore_ipc_client_send(cl, major, minor, ref, ref_to, 0, NULL, 0);
 107 }
 108
 109 static Eina_Bool _cb_client_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
 110 {
 111     IPC_HEAD(Add);
 112
 113     SDL_Log("[SDL]_cb_client_add");
 114     SDL_Window * window = SDL_GetVideoDevice()->windows;
 115     SDL_WindowData *wind = window->driverdata;
 116     wind->indicator = SDL_TRUE;
 117
 118     int window_w, window_h;
 119     ecore_wl_screen_size_get(&window_w, &window_h);
 120     _tizen_ecore_ipc_client_send(OP_RESIZE, wind->rotation, window_w, window_h);
 121
 122     return ECORE_CALLBACK_DONE;
 123 }
 124
 125 static Eina_Bool _cb_client_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
 126 {
 127     IPC_HEAD(Del);
 128     SDL_Log("[SDL]_cb_client_del");
 129     Eina_List *ipc_clients = ecore_ipc_server_clients_get(ipc);
 130     Eina_List *l;
 131     Ecore_Ipc_Client *cl;
 132     EINA_LIST_FOREACH(ipc_clients, l, cl)
 133     {
 134         ecore_ipc_client_del(cl);
 135     }
 136
 137     SDL_Window * window = SDL_GetVideoDevice()->windows;
 138     SDL_WindowData *wind = window->driverdata;
 139     wind->indicator = SDL_FALSE;
 140     return ECORE_CALLBACK_DONE;
 141 }
 142
 143 static Eina_Bool _cb_client_data(void *data, int type EINA_UNUSED, void *event)
 144 {
 145     IPC_HEAD(Data);
 146
 147     Ecore_Ipc_Event_Server_Data* epcEvent = (Ecore_Ipc_Event_Server_Data*)event;
 148     SDL_Log("[SDL]_cb_client_data: %d -> %d", epcEvent->major, epcEvent->minor);
 149     return ECORE_CALLBACK_DONE;
 150 }
 151
 152 int _tizen_init_ecore_ipc()
 153 {
 154
 155     if(!ipc)
 156     {
 157         if(!ecore_ipc_init())
 158             SDL_Log("[SDL]Fail ecore_ipc");
 159
 160         ipc = ecore_ipc_server_add(ECORE_IPC_LOCAL_USER, "sdl_indicator", 0, NULL);
 161
 162         if(!ipc)
 163             ecore_ipc_shutdown();
 164
 165         ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_ADD, _cb_client_add, NULL);
 166         ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DEL, _cb_client_del, NULL);
 167         ecore_event_handler_add(ECORE_IPC_EVENT_CLIENT_DATA, _cb_client_data, NULL);
 168     }
 169     return 0;
 170 }
 171
 172 static int
 173 _tizen_rotation_type_get()
 174 {
 175     static int type = ROTATION_TYPE_PRE_ROTATION;
 176     static int checked = 0;
 177     char *engine = NULL;
 178
 179     if (checked) return type;
 180
 181     engine = getenv("SDL_ROTATION");
 182
 183     if (engine)
 184       {
 185          if ((!strcasecmp(engine, "normal")))
 186             type = ROTATION_TYPE_NORMAL_ROTATION;
 187          else if ((!strcasecmp(engine, "pre_rotation")))
 188             type = ROTATION_TYPE_PRE_ROTATION;
 189          else
 190             type = ROTATION_TYPE_PRE_ROTATION;
 191       }
 192     checked = 1;
 193     return type;
 194 }
 195
 196 int
 197 _tizen_PreRotatotion_LoadLibrary(SDL_WindowData *_this, const char *lib_path)
 198 {
 199     void *lib_dll_handle = NULL;
 200     char *path = NULL;
 201
 202     if (_this->isLoaded_pre_rotation)
 203         return SDL_TRUE;
 204
 205     _this->tizen_pre_rotation_data = (Tizen_Prerotation_Data *) SDL_calloc(1, sizeof(Tizen_Prerotation_Data));
 206     if (!_this->tizen_pre_rotation_data) {
 207         return SDL_OutOfMemory();
 208     }
 209
 210     if (!lib_path)
 211         lib_dll_handle = SDL_LoadObject(lib_path);
 212
 213     if (!lib_dll_handle) {
 214         path = "libwayland-egl.so";
 215         lib_dll_handle = SDL_LoadObject(path);
 216     }
 217
 218     _this->tizen_pre_rotation_data->prerotation_dll_handle = lib_dll_handle;
 219
 220     if (lib_dll_handle == NULL)
 221         return SDL_FALSE;
 222
 223     LOAD_FUNC(wl_egl_window_set_rotation);
 224     LOAD_FUNC(wl_egl_window_get_capabilities);
 225     _this->isLoaded_pre_rotation = 1;
 226
 227     return SDL_TRUE;
 228 }
 229
 230 SDL_bool
 231 Tizen_GetWindowWMInfo(_THIS, SDL_Window *window, SDL_SysWMinfo *info)
 232 {
 233     SDL_WindowData *wmdata = (SDL_WindowData *)window->driverdata;
 234     info->info.tizen.egl_display = NULL;
 235     info->info.tizen.egl_surface = NULL;
 236 #if SDL_VIDEO_OPENGL_EGL
 237     if (_this->egl_data)
 238     {
 239        info->info.tizen.egl_display = (void*)_this->egl_data->egl_display;
 240     }
 241     info->info.tizen.egl_surface = (void*)wmdata->egl_surface;
 242 #endif
 243     info->subsystem = SDL_SYSWM_TIZEN;
 244     return SDL_TRUE;
 245 }
 246
 247 int
 248 Tizen_SetWindowHitTest(SDL_Window *window, SDL_bool enabled)
 249 {
 250     return 0;  /* just succeed, the real work is done elsewhere. */
 251 }
 252
 253 void
 254 Tizen_SetWindowTitle(_THIS, SDL_Window * window)
 255 {
 256     SDL_WindowData *wind = window->driverdata;
 257     ecore_wl_window_title_set(wind->window, window->title);
 258 }
 259
 260 void
 261 Tizen_ShowWindow(_THIS, SDL_Window *window)
 262 {
 263     SDL_WindowData *wind = window->driverdata;
 264
 265     if(!(window->flags & SDL_WINDOW_FULLSCREEN) && !(window->flags & SDL_WINDOW_BORDERLESS) && !wind->indicator)
 266     {
 267         SDL_ExecuteIndicatorProcess();
 268     }
 269     ecore_wl_window_show(wind->window);
 270 }
 271
 272 void
 273 Tizen_HideWindow(_THIS, SDL_Window *window)
 274 {
 275     SDL_WindowData *wind = window->driverdata;
 276     ecore_wl_window_hide(wind->window);
 277 }
 278
 279 void
 280 Tizen_RaiseWindow(_THIS, SDL_Window *window)
 281 {
 282     SDL_WindowData *wind = window->driverdata;
 283     ecore_wl_window_raise(wind->window);
 284 }
 285
 286 void
 287 Tizen_SetWindowFullscreen(_THIS, SDL_Window *window,
 288                           SDL_VideoDisplay *_display, SDL_bool fullscreen)
 289 {
 290     /*DO NOTHING*/
 291 }
 292
 293 void
 294 Tizen_pre_rotation_set(SDL_WindowData *_this, int rotation)
 295 {
 296     tizen_wl_egl_window_rotation rot;
 297     if (!_this->egl_window) return;
 298
 299     switch (rotation) {
 300          case 90:
 301             rot = TIZEN_ROTATION_270;
 302             break;
 303          case 180:
 304             rot = TIZEN_ROTATION_180;
 305             break;
 306          case 270:
 307             rot = TIZEN_ROTATION_90;
 308             break;
 309          case 0:
 310             rot = TIZEN_ROTATION_0;
 311             break;
 312          default:
 313             rot = TIZEN_ROTATION_0;
 314             break;
 315       }
 316
 317       _this->tizen_pre_rotation_data->wl_egl_window_set_rotation(_this->egl_window, rot);
 318 }
 319
 320 void
 321 _tizen_window_orientaiton_hint_callback(void *userdata, const char *name, const char *oldValue, const char *newValue)
 322 {
 323     char *p_str = NULL;
 324     char orientation_type[4][20] = {"Portrait","LandscapeLeft","PortraitUpsideDown","LandscapeRight"};
 325     int checked[4] = {0,};
 326     int i;
 327     unsigned int j = 0;
 328     SDL_WindowData *wind = (SDL_WindowData*)userdata;
 329     Ecore_Wl_Window *window = wind->window;
 330
 331     if (wind->rotation_supported == 0) {
 332         return;
 333     }
 334
 335     SDL_assert(SDL_strncmp(name, SDL_HINT_ORIENTATIONS, SDL_strlen(SDL_HINT_ORIENTATIONS)) == 0);
 336
 337     if ((oldValue == NULL) && (newValue == NULL)) {
 338         return;
 339     }
 340
 341     for (i=0;i<4;i++) {
 342         p_str = SDL_strstr(newValue, orientation_type[i]);
 343         if (p_str) {
 344             if (p_str == newValue) {
 345                 int rot = 0;
 346                 if (i == 0) rot = 0;
 347                 else if (i == 1) rot = 90;
 348                 else if (i == 2) rot = 180;
 349                 else if (i == 3) rot = 270;
 350                 wind->rotation = rot;
 351             }
 352
 353             if (i == 0) {
 354                 checked[j] = 0;
 355             }
 356             else if (i == 1) {
 357                 checked[j] = 90;
 358             }
 359             else if (i == 2) {
 360                 checked[j] = 180;
 361             }
 362             else if (i == 3) {
 363                 checked[j] = 270;
 364             }
 365             j++;
 366         }
 367     }
 368
 369     if (j > 0) {
 370         if (j == 1) {
 371             ecore_wl_window_rotation_preferred_rotation_set(window, wind->rotation);
 372         }else {
 373             ecore_wl_window_rotation_available_rotations_set(window, (const int*)checked, j);
 374         }
 375     }
 376     _tizen_rotate_update(wind);
 377 }
 378
 379 void
 380 _tizen_window_orientation_add_hint(void *data)
 381 {
 382     SDL_WindowData *wind = (SDL_WindowData*)data;
 383     if (wind->rotation_supported == 0) {
 384         return;
 385     }
 386
 387     SDL_AddHintCallback(SDL_HINT_ORIENTATIONS, _tizen_window_orientaiton_hint_callback, data);
 388 }
 389
 390 static Eina_Bool
 391 _tizen_cb_output_transform(void *data, int type EINA_UNUSED, void *event)
 392 {
 393     SDL_Window * window = SDL_GetVideoDevice()->windows;
 394     SDL_WindowData *wind = window->driverdata;
 395
 396     if(!wind) return ECORE_CALLBACK_PASS_ON;
 397
 398     Ecore_Wl_Event_Output_Transform *ev = event;
 399     Ecore_Wl_Output *output;
 400
 401     output = ecore_wl_window_output_find(wind->window);
 402     if (output != ev->output) return ECORE_CALLBACK_PASS_ON;
 403
 404     wind->received_rotation = 1;
 405
 406
 407    return ECORE_CALLBACK_PASS_ON;
 408 }
 409
 410 static Eina_Bool
 411 _tizen_cb_ignore_output_transform(void *data, int type EINA_UNUSED, void *event EINA_UNUSED)
 412 {
 413     SDL_Window * window = SDL_GetVideoDevice()->windows;
 414     SDL_WindowData *wind = window->driverdata;
 415
 416     if(!wind) return ECORE_CALLBACK_PASS_ON;
 417
 418     wind->received_rotation = 1;
 419
 420    return ECORE_CALLBACK_PASS_ON;
 421 }
 422
 423 void
 424 _tizen_output_transform_register(SDL_WindowData *wind)
 425 {
 426     if(!wind) return;
 427
 428     Ecore_Wl_Output *output = ecore_wl_window_output_find(wind->window);
 429     wind->output_rotation = ecore_wl_output_transform_get(output) * 90;
 430
 431     ecore_event_handler_add(ECORE_WL_EVENT_OUTPUT_TRANSFORM,
 432                              _tizen_cb_output_transform, NULL);
 433     ecore_event_handler_add(ECORE_WL_EVENT_IGNORE_OUTPUT_TRANSFORM,
 434                              _tizen_cb_ignore_output_transform, NULL);
 435
 436 }
 437
 438 void
 439 _tizen_send_rotation_event(SDL_Window *window, unsigned int angle)
 440 {
 441     SDL_Event event;
 442     SDL_WindowData *wind;
 443     wind = window->driverdata;
 444
 445     SDL_memset(&event, 0, sizeof(event));
 446     event.type = SDL_ROTATEEVENT;
 447     event.user.code = 0;
 448     if (wind->support_pre_rotation)
 449         event.user.data1 = (void*)0;
 450     else
 451         event.user.data1 = (void*)angle;
 452     event.user.data2 = (void*)-1;
 453
 454     SDL_PushEvent(&event);
 455     return;
 456 }
 457
 458 void
 459 _tizen_set_window_size(SDL_Window * window, int w, int h)
 460 {
 461     if(!window)
 462     {
 463         SDL_SetError("Invalid window");
 464         return;
 465     }
 466
 467     SDL_VideoDevice *_this = SDL_GetVideoDevice();
 468     if (!_this) {
 469         SDL_SetError("Video subsystem has not been initialized");
 470         return;
 471     }
 472
 473     if (window->magic != &_this->window_magic) {
 474         return;
 475     }
 476
 477     if (w <= 0) {
 478         SDL_InvalidParamError("w");
 479         return;
 480     }
 481     if (h <= 0) {
 482         SDL_InvalidParamError("h");
 483         return;
 484     }
 485
 486     /* Make sure we don't exceed any window size limits */
 487     if (window->min_w && w < window->min_w)
 488     {
 489         w = window->min_w;
 490     }
 491     if (window->max_w && w > window->max_w)
 492     {
 493         w = window->max_w;
 494     }
 495     if (window->min_h && h < window->min_h)
 496     {
 497         h = window->min_h;
 498     }
 499     if (window->max_h && h > window->max_h)
 500     {
 501         h = window->max_h;
 502     }
 503
 504     window->windowed.w = w;
 505     window->windowed.h = h;
 506
 507     window->w = w;
 508     window->h = h;
 509 }
 510
 511 void
 512 _tizen_rotation_do(SDL_WindowData *wind, int rotation)
 513 {
 514     if(!wind) return;
 515
 516     SDL_Window *window = SDL_GetVideoDevice()->windows;
 517     if(!window) return;
 518
 519     int window_w, window_h;
 520     if(wind->rotation == 0 || wind->rotation == 180)
 521         ecore_wl_window_geometry_get(wind->window, 0, 0, &window_w, &window_h);
 522     else
 523         ecore_wl_window_geometry_get(wind->window, 0, 0, &window_h, &window_w);
 524
 525     _tizen_set_window_size(window, window_w, window_h);
 526
 527     if(wind->support_pre_rotation)
 528         Tizen_pre_rotation_set(wind, rotation);
 529
 530     _tizen_send_rotation_event(window, wind->rotation);
 531     SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SIZE_CHANGED, window->w, window->h);
 532
 533 }
 534
 535 void
 536 _tizen_rotate_update(SDL_WindowData *wind)
 537 {
 538     if(!wind) return;
 539
 540     int screen_rotation;
 541     if (ecore_wl_window_ignore_output_transform_get(wind->window))
 542     {
 543         screen_rotation = 0;
 544     }
 545     else
 546     {
 547         Ecore_Wl_Output *output = ecore_wl_window_output_find(wind->window);
 548         screen_rotation = ecore_wl_output_transform_get(output) * 90;
 549     }
 550
 551     //Set Screen Rotation
 552     wind->output_rotation = screen_rotation;
 553     if(wind->support_pre_rotation)
 554         ecore_wl_window_buffer_transform_set(wind->window, wind->output_rotation / 90);
 555
 556     ecore_wl_window_rotation_set(wind->window, wind->rotation);
 557
 558     int rotation = (wind->output_rotation + wind->rotation) % 360;
 559     _tizen_rotation_do(wind, rotation);
 560 }
 561
 562 int
 563 Tizen_CreateWindow(_THIS, SDL_Window *window)
 564 {
 565     SDL_VideoData *data = _this->driverdata;
 566     SDL_WindowData *wind;
 567     Ecore_Wl_Global *global;
 568     Eina_Inlist *globals;
 569
 570     wind = calloc(1, sizeof * wind);
 571     if (!wind) {
 572         return SDL_OutOfMemory();
 573     }
 574
 575     window->driverdata = wind;
 576     window->flags |= SDL_WINDOW_INPUT_FOCUS;    /* always has input focus */
 577
 578 #if SDL_VIDEO_OPENGL_EGL
 579     if (window->flags & SDL_WINDOW_OPENGL) {
 580         SDL_GL_LoadLibrary(NULL);
 581     }
 582 #endif
 583
 584 #if SDL_VIDEO_VULKAN
 585     if (window->flags & SDL_WINDOW_VULKAN) {
 586         if (!_this->vulkan_GetInstanceExtensions) {
 587             SDL_SetError("No Vulkan support in video driver");
 588         }
 589
 590         if (_this->vulkan_LoadLibrary(_this, NULL) < 0) {
 591             SDL_SetError("Fail to load Vulkan Library");
 592         }
 593     }
 594 #endif
 595
 596     if (window->x == SDL_WINDOWPOS_UNDEFINED) {
 597         window->x = 0;
 598     }
 599     if (window->y == SDL_WINDOWPOS_UNDEFINED) {
 600         window->y = 0;
 601     }
 602
 603     if (!(globals = ecore_wl_globals_get()))
 604       {
 605          SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to get wayland globals");
 606          return -1;
 607       }
 608
 609     wind->window = ecore_wl_window_new(NULL,
 610                                        window->x, window->y, window->w, window->h,
 611                                        ECORE_WL_WINDOW_BUFFER_TYPE_SHM);
 612     if (!wind->window) {
 613         SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to create wayland window");
 614         return -1;
 615     }
 616     _tizen_output_transform_register(wind);
 617
 618     wind->surface = ecore_wl_window_surface_create(wind->window);
 619     if (!wind->surface) {
 620         SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "Failed to create wayland window surface");
 621         return -1;
 622     }
 623     ecore_wl_window_type_set(wind->window, ECORE_WL_WINDOW_TYPE_UTILITY);
 624
 625     wind->rotation = 0;
 626     wind->rotation_supported = 0;
 627     wind->received_rotation = 0;
 628
 629 #if SDL_VIDEO_OPENGL_EGL
 630     if (window->flags & SDL_WINDOW_OPENGL) {
 631
 632         if(wind->output_rotation == 90 || wind->output_rotation == 270)
 633             wind->egl_window = wl_egl_window_create(wind->surface, window->h, window->w);
 634         else
 635             wind->egl_window = wl_egl_window_create(wind->surface, window->w, window->h);
 636
 637         /* Create the GLES window surface */
 638         wind->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) wind->egl_window);
 639         if (wind->egl_surface == EGL_NO_SURFACE) {
 640             SDL_LogError(SDL_LOG_CATEGORY_ASSERT, "failed to create a window surface");
 641             return -1;
 642         }
 643
 644         if (!_this->gl_config.alpha_size) {
 645             ecore_wl_window_opaque_region_set(wind->window, window->x, window->y, window->w, window->h);
 646         }
 647         else {
 648             wl_surface_set_opaque_region(wind->surface, NULL);
 649         }
 650
 651         //Support PreRotation
 652         wind->support_pre_rotation = 0;
 653         if (_tizen_rotation_type_get() && _tizen_PreRotatotion_LoadLibrary(wind, "libwayland-egl.so")) {
 654             if (wind->tizen_pre_rotation_data->wl_egl_window_get_capabilities(wind->egl_window) == TIZEN_WL_EGL_WINDOW_CAPABILITY_ROTATION_SUPPORTED ) {
 655                 wind->support_pre_rotation = 1;
 656             }
 657         }
 658         else
 659         {
 660             wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
 661         }
 662
 663     }
 664 #endif
 665
 666     wind->id = ecore_wl_window_id_get(wind->window);
 667     eina_hash_add(data->windows, &wind->id, window);
 668
 669     Tizen_InitKeyboard(_this);
 670     SDL_SetMouseFocus(window);
 671
 672     if (window->flags & 0x00008000) {
 673         ecore_wl_window_input_region_set(wind->window, -1, -1, 1, 1);
 674         ecore_wl_window_focus_skip_set(wind->window, EINA_TRUE);
 675     }
 676
 677     EINA_INLIST_FOREACH(globals, global) {
 678          if (!strcmp(global->interface, "tizen_policy_ext")) {
 679               wind->rotation_supported = 1;
 680               break;
 681            }
 682       }
 683     // Add orientaiton hint cb
 684     _tizen_window_orientation_add_hint((void*)wind);
 685
 686     _tizen_rotate_update(wind);
 687
 688     return 0;
 689 }
 690
 691 void
 692 Tizen_SetWindowBordered(_THIS, SDL_Window * window, SDL_bool bordered)
 693 {
 694     SDL_WindowData *wind = window->driverdata;
 695     if(!wind->indicator)
 696     {
 697         SDL_ExecuteIndicatorProcess();
 698     }
 699 }
 700
 701 void
 702 _tizen_window_resize(SDL_Window *window)
 703 {
 704     SDL_WindowData *wind = window->driverdata;
 705     if (!wind->egl_window) {
 706         return;
 707     }
 708
 709     if(wind->support_pre_rotation && (wind->rotation==90 || wind->rotation==270))
 710         ecore_wl_window_update_size(wind->window, window->h, window->w);
 711     else
 712         ecore_wl_window_update_size(wind->window, window->w, window->h);
 713
 714     // TODO : consider to rotation status.
 715 #if SDL_VIDEO_OPENGL_EGL
 716     if (window->flags & SDL_WINDOW_OPENGL) {
 717       if(wind->output_rotation==90 || wind->output_rotation==270)
 718           wl_egl_window_resize(wind->egl_window, window->h, window->w, 0, 0);
 719       else
 720           wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0);
 721     }
 722 #endif
 723 }
 724
 725 void
 726 _tizen_setwindowsize(SDL_Window *window)
 727 {
 728     SDL_WindowData *wind = window->driverdata;
 729     if (!wind->window) {
 730         return;
 731     }
 732 }
 733
 734 void
 735 Tizen_SetWindowSize(_THIS, SDL_Window *window)
 736 {
 737     _tizen_window_resize(window);
 738 }
 739
 740 void
 741 Tizen_GetWindowSize(_THIS, SDL_Window *window, int *w, int *h)
 742 {
 743     SDL_WindowData *wind = window->driverdata;
 744     if (!wind->window) {
 745         return;
 746     }
 747
 748     if (w) *w = window->w;
 749     if (h) *h = window->h;
 750 }
 751
 752 void
 753 Tizen_SetWindowPosition(_THIS, SDL_Window * window)
 754 {
 755     SDL_WindowData *wind = window->driverdata;
 756     if (!wind->window) {
 757         return;
 758     }
 759
 760     // TODO : consider to rotation status.
 761    ecore_wl_window_position_set(wind->window, window->x, window->y);
 762 }
 763
 764 void
 765 Tizen_DestroyWindow(_THIS, SDL_Window *window)
 766 {
 767     SDL_VideoData *data = _this->driverdata;
 768     SDL_WindowData *wind = window->driverdata;
 769
 770     if (data) {
 771         eina_hash_del(data->windows, &wind->id, window);
 772 #if SDL_VIDEO_OPENGL_EGL
 773     if (window->flags & SDL_WINDOW_OPENGL) {
 774         SDL_EGL_DestroySurface(_this, wind->egl_surface);
 775         wl_egl_window_destroy(wind->egl_window);
 776     }
 777 #endif
 778         ecore_wl_window_free(wind->window);
 779         SDL_free(wind);
 780     }
 781
 782     window->driverdata = NULL;
 783 }
 784
 785 SDL_Window*
 786 Tizen_FindWindow(_THIS, Ecore_Wl_Window *ewin)
 787 {
 788     SDL_VideoData *data = _this->driverdata;
 789     int id;
 790
 791     id = ecore_wl_window_id_get(ewin);
 792     return (SDL_Window*)eina_hash_find(data->windows, &id);
 793 }
 794
 795 Eina_Bool
 796 _tizen_cb_event_window_visibility_change(void *data, int type, void *event)
 797 {
 798     _THIS = data;
 799     Ecore_Wl_Event_Window_Visibility_Change *ev;
 800     Ecore_Wl_Window *ew;
 801     SDL_Window *window;
 802
 803     ev = event;
 804     ew = ecore_wl_window_find(ev->win);
 805     window = Tizen_FindWindow(_this, ew);
 806
 807     SDL_SendWindowEvent(window, SDL_WINDOWEVENT_SHOWN, 0, 0);
 808     SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESTORED, 0, 0);
 809     return ECORE_CALLBACK_PASS_ON;
 810 }
 811
 812 Eina_Bool
 813 _tizen_cb_window_configure(void *data, int type EINA_UNUSED, void *event)
 814 {
 815    _THIS = data;
 816    Ecore_Wl_Window *ew;
 817    SDL_Window *window;
 818    SDL_WindowData *wind;
 819    Ecore_Wl_Event_Window_Configure *ev;
 820    ev = event;
 821    ew = ecore_wl_window_find(ev->win);
 822    window = Tizen_FindWindow(_this, ew);
 823    wind = window->driverdata;
 824
 825    if (wind->rotation_supported == 0){
 826       return ECORE_CALLBACK_PASS_ON;
 827    }
 828 /*
 829    int nx = 0, ny = 0, nw = 0, nh = 0;
 830   SDL_Log( "configure notify window: %p, ecore_wl_window: %p\n", window, ew);
 831
 832    ecore_wl_window_geometry_get(ew, &nx, &ny, &nw, &nh);
 833    if (nw < 1) nw = 1;
 834    if (nh < 1) nh = 1;
 835
 836    SDL_Log("[SDL_Size] * _tizen_cb_window_configure :: w->w:%d, w->h:%d, nw:%d, nh:%d", window->w, window->h, nw, nh);
 837    if ((window->x != nx) || (window->y != ny))
 838      ecore_wl_window_position_set(ew, nx, ny);
 839
 840    if ((window->w != nw) || (window->h != nh)) {
 841      _tizen_setwindowsize(window);
 842    }
 843    */
 844    return ECORE_CALLBACK_PASS_ON;
 845 }
 846
 847
 848 Eina_Bool
 849 _tizen_cb_event_window_rotate(void *data, int type EINA_UNUSED, void *event)
 850 {
 851     _THIS = data;
 852     Ecore_Wl_Event_Window_Rotate *ev;
 853     Ecore_Wl_Window *ew;
 854     SDL_Window *window;
 855     SDL_WindowData *wind;
 856
 857     ev = event;
 858     if (!ev) {
 859         return ECORE_CALLBACK_PASS_ON;
 860     }
 861
 862     ew = ecore_wl_window_find(ev->win);
 863     window = Tizen_FindWindow(_this, ew);
 864     wind = window->driverdata;
 865
 866     if (wind->rotation != ev->angle) {
 867         /* set ecore_wayland window rotation */
 868         wind->rotation = ev->angle;
 869         wind->received_rotation = 1;
 870     }
 871
 872     return ECORE_CALLBACK_PASS_ON;
 873 }
 874
 875 int
 876 Tizen_InitWindow(_THIS)
 877 {
 878     SDL_VideoData *data = _this->driverdata;
 879
 880     data->windows = eina_hash_int32_new(NULL);
 881
 882     ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_VISIBILITY_CHANGE,
 883                         _tizen_cb_event_window_visibility_change,_this);
 884     ecore_event_handler_add(ECORE_EVENT_KEY_UP,
 885                         _tizen_cb_event_keyup_change,_this);
 886     ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
 887                         _tizen_cb_event_keydown_change,_this);
 888     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
 889                         _tizen_cb_event_mousedown_change,_this);
 890     ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
 891                         _tizen_cb_event_mouseup_change,_this);
 892     ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE,
 893                         _tizen_cb_event_mousemove_change,_this);
 894     ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_ROTATE,
 895                         _tizen_cb_event_window_rotate,_this);
 896     ecore_event_handler_add(ECORE_WL_EVENT_WINDOW_CONFIGURE,
 897                         _tizen_cb_window_configure,_this);
 898     ecore_event_handler_add(ECORE_EVENT_JOYSTICK,
 899                         _tizen_cb_event_joystick_change,_this);
 900     ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_IN,
 901                         _tizen_cb_event_focus_in,_this);
 902     ecore_event_handler_add(ECORE_WL_EVENT_FOCUS_OUT,
 903                         _tizen_cb_event_focus_out,_this);
 904     ecore_event_handler_add(ECORE_WL_EVENT_MOUSE_IN,
 905                         _tizen_cb_event_mouse_in,_this);
 906     ecore_event_handler_add(ECORE_WL_EVENT_MOUSE_OUT,
 907                         _tizen_cb_event_mouse_out,_this);
 908
 909     return 0;
 910 }
 911
 912 void
 913 Tizen_DeinitWindow(_THIS)
 914 {
 915     SDL_VideoData *data = _this->driverdata;
 916
 917     eina_hash_free(data->windows);
 918 }
 919 #endif /* SDL_VIDEO_DRIVER_TIZEN */
 920
 921 /* vi: set ts=4 sw=4 expandtab: */