VisualBench on windows

src/views/win/SkOSWindow_win.cpp

 
 /*
  * 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)
@@ skipping 14 matching lines @@
 #include "gl/GrGLInterface.h"
 #include "GLES2/gl2.h"
 
 #define ANGLE_GL_CALL(IFACE, X)                                 \
     do {                                                        \
         (IFACE)->fFunctions.f##X;                               \
     } while (false)
 
 #endif
 
-static SkOSWindow* gCurrOSWin;
-static HWND gEventTarget;
-
 #define WM_EVENT_CALLBACK (WM_USER+0)
 
-void post_skwinevent()
+void post_skwinevent(HWND hwnd)
 {
-    PostMessage(gEventTarget, WM_EVENT_CALLBACK, 0, 0);
+    PostMessage(hwnd, WM_EVENT_CALLBACK, 0, 0);
 }
 
-SkOSWindow::SkOSWindow(void* hWnd) {
-    fHWND = hWnd;
+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
     fHGLRC = NULL;
 #endif
     fAttached = kNone_BackEndType;
-    gEventTarget = (HWND)hWnd;
+    fFullscreen = false;
 }
 
 SkOSWindow::~SkOSWindow() {
+    this->setFullscreen(false);
 #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
 #endif // SK_SUPPORT_GPU
+    gHwndToOSWindowMap.remove(fHWND);
+    DestroyWindow((HWND)fHWND);
 }
 
 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 },
@@ skipping 61 matching lines @@
                               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();
+                post_skwinevent(hWnd);
             }
             return true;
     }
     return false;
 }
 
 void SkOSWindow::doPaint(void* ctx) {
     this->update(NULL);
 
     if (kNone_BackEndType == fAttached)
@@ skipping 28 matching lines @@
             0, 0,
             0, bitmap.height(),
             bitmap.getPixels(),
             &bmi,
             DIB_RGB_COLORS);
         (void)ret; // we're ignoring potential failures for now.
         bitmap.unlockPixels();
     }
 }
 
-#if 0
 void SkOSWindow::updateSize()
 {
     RECT    r;
-    GetWindowRect((HWND)this->getHWND(), &r);
+    GetWindowRect((HWND)fHWND, &r);
     this->resize(r.right - r.left, r.bottom - r.top);
 }
-#endif
 
 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);
 }
 
@@ skipping 54 matching lines @@
     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()
 {
-    post_skwinevent();
-    //SkDebugf("signal nonempty\n");
+    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");
 }
 
@@ skipping 55 matching lines @@
     return false;
 }
 
 void SkOSWindow::detachGL() {
     wglMakeCurrent(GetDC((HWND)fHWND), 0);
     wglDeleteContext((HGLRC)fHGLRC);
     fHGLRC = NULL;
 }
 
 void SkOSWindow::presentGL() {
-    glFlush();
     HDC dc = GetDC((HWND)fHWND);
     SwapBuffers(dc);
     ReleaseDC((HWND)fHWND, dc);
 }
 
 #if SK_ANGLE
 
 bool create_ANGLE(EGLNativeWindowType hWnd,
                   int msaaSampleCount,
                   EGLDisplay* eglDisplay,
@@ skipping 221 matching lines @@
         presentANGLE();
         break;
 #endif // SK_ANGLE
 #endif // SK_SUPPORT_GPU
     default:
         SkASSERT(false);
         break;
     }
 }
 
+void SkOSWindow::setFullscreen(bool fullscreen) {
+    if (fullscreen == fFullscreen) {
+        return;
+    }
+    if (fHGLRC) {
+        this->detachGL();
+    }
+    // This is hacked together from various sources on the web. It can certainly be improved and be
+    // made more robust.
+    if (fullscreen) {
+        // Save current window/resolution information.
+        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 dmScreenSettings;                   // Device Mode
+        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));       // Makes Sure Memory's Cleared
+        dmScreenSettings.dmSize=sizeof(dmScreenSettings);       // Size Of The Devmode Structure
+        EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dmScreenSettings);
+        fSavedWindowState.fScreenWidth = dmScreenSettings.dmPelsWidth;
+        fSavedWindowState.fScreenHeight = dmScreenSettings.dmPelsHeight;
+        fSavedWindowState.fScreenBits = dmScreenSettings.dmBitsPerPel;
+        fSavedWindowState.fHWND = fHWND;
+    }
+
+    if (fullscreen) {
+        // Try different sizes to find an allowed setting? Use ChangeDisplaySettingsEx?
+        static const int kWidth = 1280;
+        static const int kHeight = 1024;
+        DEVMODE dmScreenSettings;
+        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
+        dmScreenSettings.dmSize=sizeof(dmScreenSettings);
+        dmScreenSettings.dmPelsWidth    = kWidth;
+        dmScreenSettings.dmPelsHeight   = kHeight;
+        dmScreenSettings.dmBitsPerPel   = 32;
+        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
+        if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
+            return;
+        }
+        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;
+        }
+        // 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();
+    } else {
+        DEVMODE dmScreenSettings;
+        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
+        dmScreenSettings.dmSize=sizeof(dmScreenSettings);
+        dmScreenSettings.dmPelsWidth    = fSavedWindowState.fScreenWidth;
+        dmScreenSettings.dmPelsHeight   = fSavedWindowState.fScreenHeight;
+        dmScreenSettings.dmBitsPerPel   = fSavedWindowState.fScreenBits;
+        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
+        if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
+            return;
+        }
+        gHwndToOSWindowMap.remove(fHWND);
+        DestroyWindow((HWND)fHWND);
+        fHWND = fSavedWindowState.fHWND;
+        gHwndToOSWindowMap.set(fHWND, this);
+        ShowWindow((HWND)fHWND, SW_SHOW);
+        SetWindowLong((HWND)fHWND, GWL_STYLE, fSavedWindowState.fStyle);
+        SetWindowLong((HWND)fHWND, GWL_EXSTYLE, fSavedWindowState.fExStyle);
+
+        int width = fSavedWindowState.fRect.right - fSavedWindowState.fRect.left;
+        int height = fSavedWindowState.fRect.right - fSavedWindowState.fRect.left;
+        SetWindowPos((HWND)fHWND, NULL, fSavedWindowState.fRect.left, fSavedWindowState.fRect.top,
+                     width, height,
+                     SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
+        if (fSavedWindowState.fZoomed) {
+            SendMessage((HWND)fHWND, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
+        }
+        this->updateSize();
+    }
+    fFullscreen = fullscreen;
+}
+
+void SkOSWindow::setVsync(bool enable) {
+    SkWGLExtensions wgl;
+    wgl.swapInterval(enable ? 1 : 0);
+}
+
+void SkOSWindow::closeWindow() {
+    this->setFullscreen(false);
+    DestroyWindow((HWND)fHWND);
+}
 #endif