blob: 3a2a5f6e47b366bd1e6e1db58947c54eacc6e9b0 [file] [log] [blame]
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkTypes.h"
#if defined(SK_BUILD_FOR_WIN)
#include <GL/gl.h>
#include <WindowsX.h>
#include "win/SkWGL.h"
#include "SkWindow.h"
#include "SkCanvas.h"
#include "SkOSMenu.h"
#include "SkTime.h"
#include "SkUtils.h"
#include "SkGraphics.h"
#if SK_ANGLE
#include "gl/angle/SkANGLEGLContext.h"
#include "gl/GrGLInterface.h"
#include "GLES2/gl2.h"
#define ANGLE_GL_CALL(IFACE, X) \
do { \
(IFACE)->fFunctions.f##X; \
} while (false)
#endif // SK_ANGLE
#if SK_COMMAND_BUFFER
#include "gl/command_buffer/SkCommandBufferGLContext.h"
#define COMMAND_BUFFER_GL_CALL(IFACE, X) \
do { \
(IFACE)->fFunctions.f##X; \
} while (false)
#endif // SK_COMMAND_BUFFER
#define WM_EVENT_CALLBACK (WM_USER+0)
void post_skwinevent(HWND hwnd)
{
PostMessage(hwnd, WM_EVENT_CALLBACK, 0, 0);
}
SkTHashMap<void*, SkOSWindow*> SkOSWindow::gHwndToOSWindowMap;
SkOSWindow::SkOSWindow(const void* winInit) {
fWinInit = *(const WindowInit*)winInit;
fHWND = CreateWindow(fWinInit.fClass, NULL, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, fWinInit.fInstance, NULL);
gHwndToOSWindowMap.set(fHWND, this);
#if SK_SUPPORT_GPU
#if SK_ANGLE
fDisplay = EGL_NO_DISPLAY;
fContext = EGL_NO_CONTEXT;
fSurface = EGL_NO_SURFACE;
#endif
#if SK_COMMAND_BUFFER
fCommandBuffer = nullptr;
#endif // SK_COMMAND_BUFFER
fHGLRC = NULL;
#endif
fAttached = kNone_BackEndType;
fFullscreen = false;
}
SkOSWindow::~SkOSWindow() {
#if SK_SUPPORT_GPU
if (fHGLRC) {
wglDeleteContext((HGLRC)fHGLRC);
}
#if SK_ANGLE
if (EGL_NO_CONTEXT != fContext) {
eglDestroyContext(fDisplay, fContext);
fContext = EGL_NO_CONTEXT;
}
if (EGL_NO_SURFACE != fSurface) {
eglDestroySurface(fDisplay, fSurface);
fSurface = EGL_NO_SURFACE;
}
if (EGL_NO_DISPLAY != fDisplay) {
eglTerminate(fDisplay);
fDisplay = EGL_NO_DISPLAY;
}
#endif // SK_ANGLE
#if SK_COMMAND_BUFFER
delete fCommandBuffer;
#endif // SK_COMMAND_BUFFER
#endif // SK_SUPPORT_GPU
this->closeWindow();
}
static SkKey winToskKey(WPARAM vk) {
static const struct {
WPARAM fVK;
SkKey fKey;
} gPair[] = {
{ VK_BACK, kBack_SkKey },
{ VK_CLEAR, kBack_SkKey },
{ VK_RETURN, kOK_SkKey },
{ VK_UP, kUp_SkKey },
{ VK_DOWN, kDown_SkKey },
{ VK_LEFT, kLeft_SkKey },
{ VK_RIGHT, kRight_SkKey }
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gPair); i++) {
if (gPair[i].fVK == vk) {
return gPair[i].fKey;
}
}
return kNONE_SkKey;
}
static unsigned getModifiers(UINT message) {
return 0; // TODO
}
bool SkOSWindow::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_KEYDOWN: {
SkKey key = winToskKey(wParam);
if (kNONE_SkKey != key) {
this->handleKey(key);
return true;
}
} break;
case WM_KEYUP: {
SkKey key = winToskKey(wParam);
if (kNONE_SkKey != key) {
this->handleKeyUp(key);
return true;
}
} break;
case WM_UNICHAR:
this->handleChar((SkUnichar) wParam);
return true;
case WM_CHAR: {
const uint16_t* c = reinterpret_cast<uint16_t*>(&wParam);
this->handleChar(SkUTF16_NextUnichar(&c));
return true;
} break;
case WM_SIZE: {
INT width = LOWORD(lParam);
INT height = HIWORD(lParam);
this->resize(width, height);
break;
}
case WM_PAINT: {
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
this->doPaint(hdc);
EndPaint(hWnd, &ps);
return true;
} break;
case WM_LBUTTONDOWN:
this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
Click::kDown_State, NULL, getModifiers(message));
return true;
case WM_MOUSEMOVE:
this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
Click::kMoved_State, NULL, getModifiers(message));
return true;
case WM_LBUTTONUP:
this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
Click::kUp_State, NULL, getModifiers(message));
return true;
case WM_EVENT_CALLBACK:
if (SkEvent::ProcessEvent()) {
post_skwinevent(hWnd);
}
return true;
}
return false;
}
void SkOSWindow::doPaint(void* ctx) {
this->update(NULL);
if (kNone_BackEndType == fAttached)
{
HDC hdc = (HDC)ctx;
const SkBitmap& bitmap = this->getBitmap();
BITMAPINFO bmi;
memset(&bmi, 0, sizeof(bmi));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = bitmap.width();
bmi.bmiHeader.biHeight = -bitmap.height(); // top-down image
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biSizeImage = 0;
//
// Do the SetDIBitsToDevice.
//
// TODO(wjmaclean):
// Fix this call to handle SkBitmaps that have rowBytes != width,
// i.e. may have padding at the end of lines. The SkASSERT below
// may be ignored by builds, and the only obviously safe option
// seems to be to copy the bitmap to a temporary (contiguous)
// buffer before passing to SetDIBitsToDevice().
SkASSERT(bitmap.width() * bitmap.bytesPerPixel() == bitmap.rowBytes());
bitmap.lockPixels();
int ret = SetDIBitsToDevice(hdc,
0, 0,
bitmap.width(), bitmap.height(),
0, 0,
0, bitmap.height(),
bitmap.getPixels(),
&bmi,
DIB_RGB_COLORS);
(void)ret; // we're ignoring potential failures for now.
bitmap.unlockPixels();
}
}
void SkOSWindow::updateSize()
{
RECT r;
GetWindowRect((HWND)fHWND, &r);
this->resize(r.right - r.left, r.bottom - r.top);
}
void SkOSWindow::onHandleInval(const SkIRect& r) {
RECT rect;
rect.left = r.fLeft;
rect.top = r.fTop;
rect.right = r.fRight;
rect.bottom = r.fBottom;
InvalidateRect((HWND)fHWND, &rect, FALSE);
}
void SkOSWindow::onAddMenu(const SkOSMenu* sk_menu)
{
}
void SkOSWindow::onSetTitle(const char title[]){
SetWindowTextA((HWND)fHWND, title);
}
enum {
SK_MacReturnKey = 36,
SK_MacDeleteKey = 51,
SK_MacEndKey = 119,
SK_MacLeftKey = 123,
SK_MacRightKey = 124,
SK_MacDownKey = 125,
SK_MacUpKey = 126,
SK_Mac0Key = 0x52,
SK_Mac1Key = 0x53,
SK_Mac2Key = 0x54,
SK_Mac3Key = 0x55,
SK_Mac4Key = 0x56,
SK_Mac5Key = 0x57,
SK_Mac6Key = 0x58,
SK_Mac7Key = 0x59,
SK_Mac8Key = 0x5b,
SK_Mac9Key = 0x5c
};
static SkKey raw2key(uint32_t raw)
{
static const struct {
uint32_t fRaw;
SkKey fKey;
} gKeys[] = {
{ SK_MacUpKey, kUp_SkKey },
{ SK_MacDownKey, kDown_SkKey },
{ SK_MacLeftKey, kLeft_SkKey },
{ SK_MacRightKey, kRight_SkKey },
{ SK_MacReturnKey, kOK_SkKey },
{ SK_MacDeleteKey, kBack_SkKey },
{ SK_MacEndKey, kEnd_SkKey },
{ SK_Mac0Key, k0_SkKey },
{ SK_Mac1Key, k1_SkKey },
{ SK_Mac2Key, k2_SkKey },
{ SK_Mac3Key, k3_SkKey },
{ SK_Mac4Key, k4_SkKey },
{ SK_Mac5Key, k5_SkKey },
{ SK_Mac6Key, k6_SkKey },
{ SK_Mac7Key, k7_SkKey },
{ SK_Mac8Key, k8_SkKey },
{ SK_Mac9Key, k9_SkKey }
};
for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
if (gKeys[i].fRaw == raw)
return gKeys[i].fKey;
return kNONE_SkKey;
}
///////////////////////////////////////////////////////////////////////////////////////
void SkEvent::SignalNonEmptyQueue()
{
SkOSWindow::ForAllWindows([](void* hWND, SkOSWindow**) {
post_skwinevent((HWND)hWND);
});
}
static UINT_PTR gTimer;
VOID CALLBACK sk_timer_proc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
SkEvent::ServiceQueueTimer();
//SkDebugf("timer task fired\n");
}
void SkEvent::SignalQueueTimer(SkMSec delay)
{
if (gTimer)
{
KillTimer(NULL, gTimer);
gTimer = NULL;
}
if (delay)
{
gTimer = SetTimer(NULL, 0, delay, sk_timer_proc);
//SkDebugf("SetTimer of %d returned %d\n", delay, gTimer);
}
}
#if SK_SUPPORT_GPU
bool SkOSWindow::attachGL(int msaaSampleCount, AttachmentInfo* info) {
HDC dc = GetDC((HWND)fHWND);
if (NULL == fHGLRC) {
fHGLRC = SkCreateWGLContext(dc, msaaSampleCount,
kGLPreferCompatibilityProfile_SkWGLContextRequest);
if (NULL == fHGLRC) {
return false;
}
glClearStencil(0);
glClearColor(0, 0, 0, 0);
glStencilMask(0xffffffff);
glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
}
if (wglMakeCurrent(dc, (HGLRC)fHGLRC)) {
// use DescribePixelFormat to get the stencil bit depth.
int pixelFormat = GetPixelFormat(dc);
PIXELFORMATDESCRIPTOR pfd;
DescribePixelFormat(dc, pixelFormat, sizeof(pfd), &pfd);
info->fStencilBits = pfd.cStencilBits;
// Get sample count if the MSAA WGL extension is present
SkWGLExtensions extensions;
if (extensions.hasExtension(dc, "WGL_ARB_multisample")) {
static const int kSampleCountAttr = SK_WGL_SAMPLES;
extensions.getPixelFormatAttribiv(dc,
pixelFormat,
0,
1,
&kSampleCountAttr,
&info->fSampleCount);
} else {
info->fSampleCount = 0;
}
glViewport(0, 0,
SkScalarRoundToInt(this->width()),
SkScalarRoundToInt(this->height()));
return true;
}
return false;
}
void SkOSWindow::detachGL() {
wglMakeCurrent(GetDC((HWND)fHWND), 0);
wglDeleteContext((HGLRC)fHGLRC);
fHGLRC = NULL;
}
void SkOSWindow::presentGL() {
HDC dc = GetDC((HWND)fHWND);
SwapBuffers(dc);
ReleaseDC((HWND)fHWND, dc);
}
#if SK_ANGLE
bool create_ANGLE(EGLNativeWindowType hWnd,
int msaaSampleCount,
EGLDisplay* eglDisplay,
EGLContext* eglContext,
EGLSurface* eglSurface,
EGLConfig* eglConfig) {
static const EGLint contextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE, EGL_NONE
};
static const EGLint configAttribList[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 8,
EGL_STENCIL_SIZE, 8,
EGL_NONE
};
static const EGLint surfaceAttribList[] = {
EGL_NONE, EGL_NONE
};
EGLDisplay display = SkANGLEGLContext::GetD3DEGLDisplay(GetDC(hWnd), false);
if (EGL_NO_DISPLAY == display) {
SkDebugf("Could not create ANGLE egl display!\n");
return false;
}
// Initialize EGL
EGLint majorVersion, minorVersion;
if (!eglInitialize(display, &majorVersion, &minorVersion)) {
return false;
}
EGLint numConfigs;
if (!eglGetConfigs(display, NULL, 0, &numConfigs)) {
return false;
}
// Choose config
bool foundConfig = false;
if (msaaSampleCount) {
static const int kConfigAttribListCnt =
SK_ARRAY_COUNT(configAttribList);
EGLint msaaConfigAttribList[kConfigAttribListCnt + 4];
memcpy(msaaConfigAttribList,
configAttribList,
sizeof(configAttribList));
SkASSERT(EGL_NONE == msaaConfigAttribList[kConfigAttribListCnt - 1]);
msaaConfigAttribList[kConfigAttribListCnt - 1] = EGL_SAMPLE_BUFFERS;
msaaConfigAttribList[kConfigAttribListCnt + 0] = 1;
msaaConfigAttribList[kConfigAttribListCnt + 1] = EGL_SAMPLES;
msaaConfigAttribList[kConfigAttribListCnt + 2] = msaaSampleCount;
msaaConfigAttribList[kConfigAttribListCnt + 3] = EGL_NONE;
if (eglChooseConfig(display, msaaConfigAttribList, eglConfig, 1, &numConfigs)) {
SkASSERT(numConfigs > 0);
foundConfig = true;
}
}
if (!foundConfig) {
if (!eglChooseConfig(display, configAttribList, eglConfig, 1, &numConfigs)) {
return false;
}
}
// Create a surface
EGLSurface surface = eglCreateWindowSurface(display, *eglConfig,
(EGLNativeWindowType)hWnd,
surfaceAttribList);
if (surface == EGL_NO_SURFACE) {
return false;
}
// Create a GL context
EGLContext context = eglCreateContext(display, *eglConfig,
EGL_NO_CONTEXT,
contextAttribs );
if (context == EGL_NO_CONTEXT ) {
return false;
}
// Make the context current
if (!eglMakeCurrent(display, surface, surface, context)) {
return false;
}
*eglDisplay = display;
*eglContext = context;
*eglSurface = surface;
return true;
}
bool SkOSWindow::attachANGLE(int msaaSampleCount, AttachmentInfo* info) {
if (EGL_NO_DISPLAY == fDisplay) {
bool bResult = create_ANGLE((HWND)fHWND,
msaaSampleCount,
&fDisplay,
&fContext,
&fSurface,
&fConfig);
if (false == bResult) {
return false;
}
SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
if (intf) {
ANGLE_GL_CALL(intf, ClearStencil(0));
ANGLE_GL_CALL(intf, ClearColor(0, 0, 0, 0));
ANGLE_GL_CALL(intf, StencilMask(0xffffffff));
ANGLE_GL_CALL(intf, Clear(GL_STENCIL_BUFFER_BIT |GL_COLOR_BUFFER_BIT));
}
}
if (eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
eglGetConfigAttrib(fDisplay, fConfig, EGL_STENCIL_SIZE, &info->fStencilBits);
eglGetConfigAttrib(fDisplay, fConfig, EGL_SAMPLES, &info->fSampleCount);
SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
if (intf ) {
ANGLE_GL_CALL(intf, Viewport(0, 0,
SkScalarRoundToInt(this->width()),
SkScalarRoundToInt(this->height())));
}
return true;
}
return false;
}
void SkOSWindow::detachANGLE() {
eglMakeCurrent(fDisplay, EGL_NO_SURFACE , EGL_NO_SURFACE , EGL_NO_CONTEXT);
eglDestroyContext(fDisplay, fContext);
fContext = EGL_NO_CONTEXT;
eglDestroySurface(fDisplay, fSurface);
fSurface = EGL_NO_SURFACE;
eglTerminate(fDisplay);
fDisplay = EGL_NO_DISPLAY;
}
void SkOSWindow::presentANGLE() {
SkAutoTUnref<const GrGLInterface> intf(GrGLCreateANGLEInterface());
if (intf) {
ANGLE_GL_CALL(intf, Flush());
}
eglSwapBuffers(fDisplay, fSurface);
}
#endif // SK_ANGLE
#if SK_COMMAND_BUFFER
bool SkOSWindow::attachCommandBuffer(int msaaSampleCount, AttachmentInfo* info) {
if (!fCommandBuffer) {
fCommandBuffer = SkCommandBufferGLContext::Create((HWND)fHWND, msaaSampleCount);
if (!fCommandBuffer)
return false;
SkAutoTUnref<const GrGLInterface> intf(GrGLCreateCommandBufferInterface());
if (intf) {
COMMAND_BUFFER_GL_CALL(intf, ClearStencil(0));
COMMAND_BUFFER_GL_CALL(intf, ClearColor(0, 0, 0, 0));
COMMAND_BUFFER_GL_CALL(intf, StencilMask(0xffffffff));
COMMAND_BUFFER_GL_CALL(intf, Clear(GL_STENCIL_BUFFER_BIT |GL_COLOR_BUFFER_BIT));
}
}
if (fCommandBuffer->makeCurrent()) {
info->fStencilBits = fCommandBuffer->getStencilBits();
info->fSampleCount = fCommandBuffer->getSampleCount();
SkAutoTUnref<const GrGLInterface> intf(GrGLCreateCommandBufferInterface());
if (intf ) {
COMMAND_BUFFER_GL_CALL(intf, Viewport(0, 0,
SkScalarRoundToInt(this->width()),
SkScalarRoundToInt(this->height())));
}
return true;
}
return false;
}
void SkOSWindow::detachCommandBuffer() {
delete fCommandBuffer;
fCommandBuffer = nullptr;
}
void SkOSWindow::presentCommandBuffer() {
fCommandBuffer->presentCommandBuffer();
}
#endif // SK_COMMAND_BUFFER
#endif // SK_SUPPORT_GPU
// return true on success
bool SkOSWindow::attach(SkBackEndTypes attachType, int msaaSampleCount, AttachmentInfo* info) {
// attach doubles as "windowResize" so we need to allo
// already bound states to pass through again
// TODO: split out the resize functionality
// SkASSERT(kNone_BackEndType == fAttached);
bool result = true;
switch (attachType) {
case kNone_BackEndType:
// nothing to do
break;
#if SK_SUPPORT_GPU
case kNativeGL_BackEndType:
result = attachGL(msaaSampleCount, info);
break;
#if SK_ANGLE
case kANGLE_BackEndType:
result = attachANGLE(msaaSampleCount, info);
break;
#endif // SK_ANGLE
#if SK_COMMAND_BUFFER
case kCommandBufferES2_BackEndType:
result = attachCommandBuffer(msaaSampleCount, info);
break;
#endif // SK_COMMAND_BUFFER
#endif // SK_SUPPORT_GPU
default:
SkASSERT(false);
result = false;
break;
}
if (result) {
fAttached = attachType;
}
return result;
}
void SkOSWindow::detach() {
switch (fAttached) {
case kNone_BackEndType:
// nothing to do
break;
#if SK_SUPPORT_GPU
case kNativeGL_BackEndType:
detachGL();
break;
#if SK_ANGLE
case kANGLE_BackEndType:
detachANGLE();
break;
#endif // SK_ANGLE
#if SK_COMMAND_BUFFER
case kCommandBufferES2_BackEndType:
detachCommandBuffer();
break;
#endif // SK_COMMAND_BUFFER
#endif // SK_SUPPORT_GPU
default:
SkASSERT(false);
break;
}
fAttached = kNone_BackEndType;
}
void SkOSWindow::present() {
switch (fAttached) {
case kNone_BackEndType:
// nothing to do
return;
#if SK_SUPPORT_GPU
case kNativeGL_BackEndType:
presentGL();
break;
#if SK_ANGLE
case kANGLE_BackEndType:
presentANGLE();
break;
#endif // SK_ANGLE
#if SK_COMMAND_BUFFER
case kCommandBufferES2_BackEndType:
presentCommandBuffer();
break;
#endif // SK_COMMAND_BUFFER
#endif // SK_SUPPORT_GPU
default:
SkASSERT(false);
break;
}
}
bool SkOSWindow::makeFullscreen() {
if (fFullscreen) {
return true;
}
#if SK_SUPPORT_GPU
if (fHGLRC) {
this->detachGL();
}
#endif // SK_SUPPORT_GPU
// This is hacked together from various sources on the web. It can certainly be improved and be
// made more robust.
// Save current window/resolution information. We do this in case we ever implement switching
// back to windowed mode.
fSavedWindowState.fZoomed = SkToBool(IsZoomed((HWND)fHWND));
if (fSavedWindowState.fZoomed) {
SendMessage((HWND)fHWND, WM_SYSCOMMAND, SC_RESTORE, 0);
}
fSavedWindowState.fStyle = GetWindowLong((HWND)fHWND, GWL_STYLE);
fSavedWindowState.fExStyle = GetWindowLong((HWND)fHWND, GWL_EXSTYLE);
GetWindowRect((HWND)fHWND, &fSavedWindowState.fRect);
DEVMODE currScreenSettings;
memset(&currScreenSettings,0,sizeof(currScreenSettings));
currScreenSettings.dmSize = sizeof(currScreenSettings);
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &currScreenSettings);
fSavedWindowState.fScreenWidth = currScreenSettings.dmPelsWidth;
fSavedWindowState.fScreenHeight = currScreenSettings.dmPelsHeight;
fSavedWindowState.fScreenBits = currScreenSettings.dmBitsPerPel;
fSavedWindowState.fHWND = fHWND;
// Try different sizes to find an allowed setting? Use ChangeDisplaySettingsEx?
static const int kWidth = 1280;
static const int kHeight = 1024;
DEVMODE newScreenSettings;
memset(&newScreenSettings, 0, sizeof(newScreenSettings));
newScreenSettings.dmSize = sizeof(newScreenSettings);
newScreenSettings.dmPelsWidth = kWidth;
newScreenSettings.dmPelsHeight = kHeight;
newScreenSettings.dmBitsPerPel = 32;
newScreenSettings.dmFields = DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
if (ChangeDisplaySettings(&newScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
return false;
}
RECT WindowRect;
WindowRect.left = 0;
WindowRect.right = kWidth;
WindowRect.top = 0;
WindowRect.bottom = kHeight;
ShowCursor(FALSE);
AdjustWindowRectEx(&WindowRect, WS_POPUP, FALSE, WS_EX_APPWINDOW);
HWND fsHWND = CreateWindowEx(
WS_EX_APPWINDOW,
fWinInit.fClass,
NULL,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP,
0, 0, WindowRect.right-WindowRect.left, WindowRect.bottom-WindowRect.top,
NULL,
NULL,
fWinInit.fInstance,
NULL
);
if (!fsHWND) {
return false;
}
// Hide the old window and set the entry in the global mapping for this SkOSWindow to the
// new HWND.
ShowWindow((HWND)fHWND, SW_HIDE);
gHwndToOSWindowMap.remove(fHWND);
fHWND = fsHWND;
gHwndToOSWindowMap.set(fHWND, this);
this->updateSize();
fFullscreen = true;
return true;
}
void SkOSWindow::setVsync(bool enable) {
SkWGLExtensions wgl;
wgl.swapInterval(enable ? 1 : 0);
}
void SkOSWindow::closeWindow() {
DestroyWindow((HWND)fHWND);
if (fFullscreen) {
DestroyWindow((HWND)fSavedWindowState.fHWND);
}
gHwndToOSWindowMap.remove(fHWND);
}
#endif