{

if (device->driverdata) {

SDL_VideoData * video_data = (SDL_VideoData *)device->driverdata;

if (video_data->winrtEglWindow) {

video_data->winrtEglWindow->Release();

}

SDL_free(video_data);

}

SDL_free(device);

{

if (WINRT_InitModes(_this) < 0) {

return -1;

}

WINRT_InitMouse(_this);

WINRT_InitTouch(_this);

return 0;

{

SDL_DisplayModeData * driverdata;

using namespace Windows::Graphics::Display;

// Go no further if a native window cannot be accessed. This can happen,

// for example, if this function is called from certain threads, such as

// the SDL/XAML thread.

if (!CoreWindow::GetForCurrentThread()) {

return SDL_SetError("SDL/WinRT display modes cannot be calculated outside of the main thread, such as in SDL's XAML thread");

}

//SDL_Log("%s, size={%f,%f}, current orientation=%d, native orientation=%d, auto rot. pref=%d, DPI = %f\n",

// __FUNCTION__,

// CoreWindow::GetForCurrentThread()->Bounds.Width, CoreWindow::GetForCurrentThread()->Bounds.Height,

// WINRT_DISPLAY_PROPERTY(CurrentOrientation),

// WINRT_DISPLAY_PROPERTY(NativeOrientation),

// WINRT_DISPLAY_PROPERTY(AutoRotationPreferences),

// WINRT_DISPLAY_PROPERTY(LogicalDpi));

// Calculate the display size given the window size, taking into account

// the current display's DPI:

#if NTDDI_VERSION > NTDDI_WIN8

const float currentDPI = DisplayInformation::GetForCurrentView()->LogicalDpi;

#else

const float currentDPI = Windows::Graphics::Display::DisplayProperties::LogicalDpi;

#endif

const float dipsPerInch = 96.0f;

const int w = (int) ((CoreWindow::GetForCurrentThread()->Bounds.Width * currentDPI) / dipsPerInch);

const int h = (int) ((CoreWindow::GetForCurrentThread()->Bounds.Height * currentDPI) / dipsPerInch);

if (w == 0 || w == h) {

return SDL_SetError("Unable to calculate the WinRT window/display's size");

}

// Create a driverdata field:

driverdata = (SDL_DisplayModeData *) SDL_malloc(sizeof(*driverdata));

if (!driverdata) {

return SDL_OutOfMemory();

}

SDL_zerop(driverdata);

// Fill in most fields:

SDL_zerop(mode);

mode->format = SDL_PIXELFORMAT_RGB888;

mode->refresh_rate = 0; // TODO, WinRT: see if refresh rate data is available, or relevant (for WinRT apps)

mode->w = w;

mode->h = h;

mode->driverdata = driverdata;

#if NTDDI_VERSION > NTDDI_WIN8

driverdata->currentOrientation = DisplayInformation::GetForCurrentView()->CurrentOrientation;

#else

driverdata->currentOrientation = DisplayProperties::CurrentOrientation;

#endif

#if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) && (NTDDI_VERSION == NTDDI_WIN8)

// On Windows Phone 8.0, the native window's size is always in portrait,

// regardless of the device's orientation. This is in contrast to

// Windows 8.x/RT and Windows Phone 8.1, which will resize the native window as the device's

// orientation changes. In order to compensate for this behavior,

// on Windows Phone, the mode's width and height will be swapped when

// the device is in a landscape (non-portrait) mode.

switch (driverdata->currentOrientation) {

case DisplayOrientations::Landscape:

case DisplayOrientations::LandscapeFlipped:

{

const int tmp = mode->h;

mode->h = mode->w;

mode->w = tmp;

break;

}

default:

break;

}

#endif

return 0;

{

SDL_DisplayModeData * driverdata;

driverdata = (SDL_DisplayModeData *) SDL_malloc(sizeof(*driverdata));

if (!driverdata) {

return SDL_OutOfMemory();

}

SDL_memcpy(driverdata, src->driverdata, sizeof(SDL_DisplayModeData));

SDL_memcpy(dest, src, sizeof(SDL_DisplayMode));

dest->driverdata = driverdata;

return 0;

{

// Retrieve the display mode:

SDL_DisplayMode mode, desktop_mode;

if (WINRT_CalcDisplayModeUsingNativeWindow(&mode) != 0) {

return -1; // If WINRT_CalcDisplayModeUsingNativeWindow fails, it'll already have set the SDL error

}

if (WINRT_DuplicateDisplayMode(&desktop_mode, &mode) != 0) {

return -1;

}

if (SDL_AddBasicVideoDisplay(&desktop_mode) < 0) {

return -1;

}

SDL_AddDisplayMode(&_this->displays[0], &mode);

return 0;

{

// Make sure that only one window gets created, at least until multimonitor

// support is added.

if (WINRT_GlobalSDLWindow != NULL) {

SDL_SetError("WinRT only supports one window");

return -1;

}

SDL_WindowData *data = new SDL_WindowData;

if (!data) {

SDL_OutOfMemory();

return -1;

}

window->driverdata = data;

data->sdlWindow = window;

/* To note, when XAML support is enabled, access to the CoreWindow will not

be possible, at least not via the SDL/XAML thread. Attempts to access it

from there will throw exceptions. As such, the SDL_WindowData's

'coreWindow' field will only be set (to a non-null value) if XAML isn't

enabled.

*/

if (!WINRT_XAMLWasEnabled) {

data->coreWindow = CoreWindow::GetForCurrentThread();

}

#if SDL_VIDEO_OPENGL_EGL

/* Setup the EGL surface, but only if OpenGL ES 2 was requested. */

if (!(window->flags & SDL_WINDOW_OPENGL)) {

/* OpenGL ES 2 wasn't requested. Don't set up an EGL surface. */

data->egl_surface = EGL_NO_SURFACE;

} else {

/* OpenGL ES 2 was reuqested. Set up an EGL surface. */

SDL_VideoData * video_data = (SDL_VideoData *)_this->driverdata;

/* Call SDL_EGL_ChooseConfig and eglCreateWindowSurface directly,

* rather than via SDL_EGL_CreateSurface, as ANGLE/WinRT requires

* a C++ object, ComPtr<IUnknown>, to be passed into

* eglCreateWindowSurface.

*/

if (SDL_EGL_ChooseConfig(_this) != 0) {

char buf[512];

SDL_snprintf(buf, sizeof(buf), "SDL_EGL_ChooseConfig failed: %s", SDL_GetError());

return SDL_SetError(buf);

}

Microsoft::WRL::ComPtr<IUnknown> cpp_winrtEglWindow = video_data->winrtEglWindow;

data->egl_surface = ((eglCreateWindowSurface_Function)_this->egl_data->eglCreateWindowSurface)(

_this->egl_data->egl_display,

_this->egl_data->egl_config,

cpp_winrtEglWindow, NULL);

if (data->egl_surface == NULL) {

return SDL_SetError("eglCreateWindowSurface failed");

}

}

#endif

/* Make sure the window is considered to be positioned at {0,0},

and is considered fullscreen, shown, and the like.

*/

window->x = 0;

window->y = 0;

window->flags =

SDL_WINDOW_FULLSCREEN |

SDL_WINDOW_SHOWN |

SDL_WINDOW_BORDERLESS |

SDL_WINDOW_MAXIMIZED |

SDL_WINDOW_INPUT_GRABBED;

#if SDL_VIDEO_OPENGL_EGL

if (data->egl_surface) {

window->flags |= SDL_WINDOW_OPENGL;

}

#endif

/* WinRT does not, as of this writing, appear to support app-adjustable

window sizes. Set the window size to whatever the native WinRT

CoreWindow is set at.

TODO, WinRT: if and when non-fullscreen XAML control support is added to SDL, consider making those resizable via SDL_Window's interfaces.

*/

window->w = _this->displays[0].current_mode.w;

window->h = _this->displays[0].current_mode.h;

/* For now, treat WinRT apps as if they always have focus.

TODO, WinRT: try tracking keyboard and mouse focus state with respect to snapped apps

*/

SDL_SetMouseFocus(window);

SDL_SetKeyboardFocus(window);

/* Make sure the WinRT app's IFramworkView can post events on

behalf of SDL:

*/

WINRT_GlobalSDLWindow = window;

/* All done! */

return 0;

{

SDL_WindowData * data = (SDL_WindowData *) window->driverdata;

if (WINRT_GlobalSDLWindow == window) {

WINRT_GlobalSDLWindow = NULL;

}

if (data) {

// Delete the internal window data:

delete data;

data = NULL;

}

{

SDL_WindowData * data = (SDL_WindowData *) window->driverdata;

if (info->version.major <= SDL_MAJOR_VERSION) {

info->subsystem = SDL_SYSWM_WINRT;

info->info.winrt.window = reinterpret_cast<IInspectable *>(data->coreWindow.Get());

return SDL_TRUE;

} else {

SDL_SetError("Application not compiled with SDL %d.%d\n",

SDL_MAJOR_VERSION, SDL_MINOR_VERSION);

return SDL_FALSE;

}

return SDL_FALSE;