Reverting r3555

git-svn-id: http://skia.googlecode.com/svn/trunk@3556 2bbb7eff-a529-9590-31e7-b0007b416f81

1 files changed, 608 insertions, 710 deletions

diff --git a/src/views/win/SkOSWindow_win.cpp b/src/views/win/SkOSWindow_win.cpp
index 6921219504..bf59e76715 100644
--- a/src/views/win/SkOSWindow_win.cpp
+++ b/src/views/win/SkOSWindow_win.cpp
@@ -1,710 +1,608 @@
-

-/*

- * 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 <d3d9.h>

-#include <WindowsX.h>

-#include "SkWGL.h"

-#include "SkWindow.h"

-#include "SkCanvas.h"

-#include "SkOSMenu.h"

-#include "SkTime.h"

-#include "SkUtils.h"

-

-#include "SkGraphics.h"

-

-#if SK_ANGLE

-#include "GLES2/gl2.h"

-#endif

-

-#define INVALIDATE_DELAY_MS 200

-

-static SkOSWindow* gCurrOSWin;

-static HWND gEventTarget;

-

-#define WM_EVENT_CALLBACK (WM_USER+0)

-

-void post_skwinevent()

-{

-    PostMessage(gEventTarget, WM_EVENT_CALLBACK, 0, 0);

-}

-

-SkOSWindow::SkOSWindow(void* hWnd) 

-    : fHWND(hWnd) 

-#if SK_ANGLE

-    , fDisplay(EGL_NO_DISPLAY)

-    , fContext(EGL_NO_CONTEXT)

-    , fSurface(EGL_NO_SURFACE)

-#endif

-    , fHGLRC(NULL)

-    , fD3D9Device(NULL)

-    , fAttached(kNone_BackEndType) {

-    gEventTarget = (HWND)hWnd;

-}

-

-SkOSWindow::~SkOSWindow() {

-    if (NULL != fD3D9Device) {

-        ((IDirect3DDevice9*)fD3D9Device)->Release();

-    }

-    if (NULL != fHGLRC) {

-        wglDeleteContext((HGLRC)fHGLRC);

-    }

-#if SK_ANGLE

-    if (EGL_NO_CONTEXT != fContext) {

-        angle::eglDestroyContext(fDisplay, fContext);

-        fContext = EGL_NO_CONTEXT;

-    }

-

-    if (EGL_NO_SURFACE != fSurface) {

-        angle::eglDestroySurface(fDisplay, fSurface);

-        fSurface = EGL_NO_SURFACE;

-    }

-

-    if (EGL_NO_DISPLAY != fDisplay) {

-        angle::eglTerminate(fDisplay);

-        fDisplay = EGL_NO_DISPLAY;

-    }

-#endif

-}

-

-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;

-}

-

-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(wParam);

-            return true; 

-        case WM_CHAR: {

-            this->handleChar(SkUTF8_ToUnichar((char*)&wParam));

-            return true;

-        } break;

-        case WM_SIZE:

-            this->resize(lParam & 0xFFFF, lParam >> 16);

-            break;

-        case WM_PAINT: {

-            PAINTSTRUCT ps;

-            HDC hdc = BeginPaint(hWnd, &ps);

-            this->doPaint(hdc);

-            EndPaint(hWnd, &ps);

-            return true;

-            } break;

-

-        case WM_TIMER: {

-            RECT* rect = (RECT*)wParam;

-            InvalidateRect(hWnd, rect, FALSE);

-            KillTimer(hWnd, (UINT_PTR)rect);

-            delete rect;

-            return true;

-        } break;

-    

-        case WM_LBUTTONDOWN: 

-            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kDown_State);

-            return true;

-                    

-        case WM_MOUSEMOVE:

-            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kMoved_State);

-            return true;

-

-        case WM_LBUTTONUP:

-            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kUp_State);

-            return true;

-

-        case WM_EVENT_CALLBACK:

-            if (SkEvent::ProcessEvent()) {

-                post_skwinevent();

-            }

-            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 iRet = SetDIBitsToDevice(hdc,

-            0, 0,

-            bitmap.width(), bitmap.height(),

-            0, 0,

-            0, bitmap.height(),

-            bitmap.getPixels(),

-            &bmi,

-            DIB_RGB_COLORS);

-        bitmap.unlockPixels();

-    }

-}

-

-#if 0

-void SkOSWindow::updateSize()

-{

-    RECT    r;

-    GetWindowRect((HWND)this->getHWND(), &r);

-    this->resize(r.right - r.left, r.bottom - r.top);

-}

-#endif

-

-void SkOSWindow::onHandleInval(const SkIRect& r) {

-    RECT* rect = new RECT;

-    rect->left    = r.fLeft;

-    rect->top     = r.fTop;

-    rect->right   = r.fRight;

-    rect->bottom  = r.fBottom;

-    SetTimer((HWND)fHWND, (UINT_PTR)rect, INVALIDATE_DELAY_MS, NULL);

-}

-

-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()

-{

-    post_skwinevent();

-    //SkDebugf("signal nonempty\n");

-}

-

-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);

-    }

-}

-

-

-#define USE_MSAA 0

-

-HGLRC create_gl(HWND hwnd) {

-

-    HDC dc = GetDC(hwnd);

-

-    SkWGLExtensions extensions;

-    if (!extensions.hasExtension(dc, "WGL_ARB_pixel_format")) {

-        return NULL;

-    }

-

-    HDC prevDC = wglGetCurrentDC();

-    HGLRC prevGLRC = wglGetCurrentContext();

-    PIXELFORMATDESCRIPTOR pfd;

-

-    int format = 0;

-

-    GLint iattrs[] = {

-        SK_WGL_DRAW_TO_WINDOW, TRUE,

-        SK_WGL_DOUBLE_BUFFER, TRUE,

-        SK_WGL_ACCELERATION, SK_WGL_FULL_ACCELERATION,

-        SK_WGL_SUPPORT_OPENGL, TRUE,

-        SK_WGL_COLOR_BITS, 24,

-        SK_WGL_ALPHA_BITS, 8,

-        SK_WGL_STENCIL_BITS, 8,

-

-        // these must be kept last

-        SK_WGL_SAMPLE_BUFFERS, TRUE,

-        SK_WGL_SAMPLES, 0,

-        0,0

-    };

-

-    static const int kSampleBuffersValueIdx = SK_ARRAY_COUNT(iattrs) - 5;

-    static const int kSamplesValueIdx = SK_ARRAY_COUNT(iattrs) - 3;

-    if (USE_MSAA && extensions.hasExtension(dc, "WGL_ARB_multisample")) {

-        for (int samples = 16; samples > 1; --samples) {

-            

-            iattrs[kSamplesValueIdx] = samples;

-            GLfloat fattrs[] = {0,0};

-            GLuint num;

-            int formats[64];

-            extensions.choosePixelFormat(dc, iattrs, fattrs, 64, formats, &num);

-            num = min(num,64);

-            for (GLuint i = 0; i < num; ++i) {

-                DescribePixelFormat(dc, formats[i], sizeof(pfd), &pfd);

-                if (SetPixelFormat(dc, formats[i], &pfd)) {

-                    format = formats[i];

-                    break;

-                }

-            }

-        }

-    }

-

-    if (0 == format) {

-        iattrs[kSampleBuffersValueIdx-1] = iattrs[kSampleBuffersValueIdx] = 0;

-        iattrs[kSamplesValueIdx-1] = iattrs[kSamplesValueIdx] = 0;

-        GLfloat fattrs[] = {0,0};

-        GLuint num;

-        extensions.choosePixelFormat(dc, iattrs, fattrs, 1, &format, &num);

-        DescribePixelFormat(dc, format, sizeof(pfd), &pfd);

-        BOOL set = SetPixelFormat(dc, format, &pfd);

-        SkASSERT(TRUE == set);

-    }

-    

-    HGLRC glrc = wglCreateContext(dc);

-    SkASSERT(glrc);

-

-    wglMakeCurrent(prevDC, prevGLRC);

-    return glrc;

-}

-

-bool SkOSWindow::attachGL() {

-    if (NULL == fHGLRC) {

-        fHGLRC = create_gl((HWND)fHWND);

-        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(GetDC((HWND)fHWND), (HGLRC)fHGLRC)) {

-        glViewport(0, 0, SkScalarRound(this->width()),

-                   SkScalarRound(this->height()));

-        return true;

-    }

-    return false;

-}

-

-void SkOSWindow::detachGL() {

-    wglMakeCurrent(GetDC((HWND)fHWND), 0);

-    wglDeleteContext((HGLRC)fHGLRC);

-    fHGLRC = NULL;

-}

-

-void SkOSWindow::presentGL() {

-    glFlush();

-    SwapBuffers(GetDC((HWND)fHWND));

-}

-

-#if SK_ANGLE

-bool create_ANGLE(EGLNativeWindowType hWnd, angle::EGLDisplay* eglDisplay,

-                  angle::EGLContext* eglContext, angle::EGLSurface* eglSurface) {

-    EGLint contextAttribs[] = { 

-        EGL_CONTEXT_CLIENT_VERSION, 2, 

-        EGL_NONE, EGL_NONE 

-    };

-    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

-    };

-    EGLint surfaceAttribList[] = {

-        EGL_NONE, EGL_NONE

-    };

-

-    angle::EGLDisplay display = angle::eglGetDisplay(GetDC(hWnd));

-    if (display == EGL_NO_DISPLAY ) {

-       return false;

-    }

-

-    // Initialize EGL

-    EGLint majorVersion, minorVersion;

-    if (!angle::eglInitialize(display, &majorVersion, &minorVersion)) {

-       return false;

-    }

-

-    EGLint numConfigs;

-    if (!angle::eglGetConfigs(display, NULL, 0, &numConfigs)) {

-       return false;

-    }

-

-    // Choose config

-    angle::EGLConfig config;

-    if (!angle::eglChooseConfig(display, configAttribList, 

-                                &config, 1, &numConfigs)) {

-       return false;

-    }

-

-    // Create a surface

-    angle::EGLSurface surface = angle::eglCreateWindowSurface(display, config, 

-                                                        (EGLNativeWindowType)hWnd, 

-                                                        surfaceAttribList);

-    if (surface == EGL_NO_SURFACE) {

-       return false;

-    }

-

-    // Create a GL context

-    angle::EGLContext context = angle::eglCreateContext(display, config, 

-                                                        EGL_NO_CONTEXT,

-                                                        contextAttribs );

-    if (context == EGL_NO_CONTEXT ) {

-       return false;

-    }   

-    

-    // Make the context current

-    if (!angle::eglMakeCurrent(display, surface, surface, context)) {

-       return false;

-    }

-    

-    *eglDisplay = display;

-    *eglContext = context;

-    *eglSurface = surface;

-    return true;

-}

-

-bool SkOSWindow::attachANGLE() {

-    if (EGL_NO_DISPLAY == fDisplay) {

-        bool bResult = create_ANGLE((HWND)fHWND, &fDisplay, &fContext, &fSurface);

-        if (false == bResult) {

-            return false;

-        }

-        angle::glClearStencil(0);

-        angle::glClearColor(0, 0, 0, 0);

-        angle::glStencilMask(0xffffffff);

-        angle::glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

-    }

-    if (angle::eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {

-        angle::glViewport(0, 0, SkScalarRound(this->width()),

-                   SkScalarRound(this->height()));

-        return true;

-    }

-    return false;

-}

-

-void SkOSWindow::detachANGLE() {

-    angle::eglMakeCurrent(fDisplay, EGL_NO_SURFACE , EGL_NO_SURFACE , EGL_NO_CONTEXT);

-

-    angle::eglDestroyContext(fDisplay, fContext);

-    fContext = EGL_NO_CONTEXT;

-

-    angle::eglDestroySurface(fDisplay, fSurface);

-    fSurface = EGL_NO_SURFACE;

-

-    angle::eglTerminate(fDisplay);

-    fDisplay = EGL_NO_DISPLAY;

-}

-

-void SkOSWindow::presentANGLE() {

-    angle::glFlush();

-    angle::eglSwapBuffers(fDisplay, fSurface);

-}

-#endif

-

-IDirect3DDevice9* create_d3d9_device(HWND hwnd) {

-    HRESULT hr;

-

-    IDirect3D9* d3d9;

-    d3d9 = Direct3DCreate9(D3D_SDK_VERSION);

-    if (NULL == d3d9) {

-        return NULL;

-    }

-    D3DDEVTYPE devType = D3DDEVTYPE_HAL;

-    //D3DDEVTYPE devType = D3DDEVTYPE_REF;

-    DWORD qLevels;

-    DWORD qLevelsDepth;

-    D3DMULTISAMPLE_TYPE type;

-    for (type = D3DMULTISAMPLE_16_SAMPLES; 

-         type >= D3DMULTISAMPLE_NONMASKABLE; --(*(DWORD*)&type)) {

-        hr = d3d9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, 

-                                              devType, D3DFMT_D24S8, TRUE,

-                                              type, &qLevels);

-        qLevels = (hr == D3D_OK) ? qLevels : 0;

-        hr = d3d9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, 

-                                              devType, D3DFMT_A8R8G8B8, TRUE,

-                                              type, &qLevelsDepth);

-        qLevelsDepth = (hr == D3D_OK) ? qLevelsDepth : 0;

-        qLevels = min(qLevels,qLevelsDepth);

-        if (qLevels > 0) {

-            break;

-        }

-    }

-    qLevels = 0;

-    IDirect3DDevice9* d3d9Device;

-    D3DPRESENT_PARAMETERS pres;

-    memset(&pres, 0, sizeof(pres));

-    pres.EnableAutoDepthStencil = TRUE;

-    pres.AutoDepthStencilFormat = D3DFMT_D24S8;

-    pres.BackBufferCount = 2;

-    pres.BackBufferFormat = D3DFMT_A8R8G8B8;

-    pres.BackBufferHeight = 0;

-    pres.BackBufferWidth = 0;

-    if (qLevels > 0) {

-        pres.MultiSampleType = type;

-        pres.MultiSampleQuality = qLevels-1;

-    } else {

-        pres.MultiSampleType = D3DMULTISAMPLE_NONE;

-        pres.MultiSampleQuality = 0;

-    }

-    pres.SwapEffect = D3DSWAPEFFECT_DISCARD;

-    pres.Windowed = TRUE;

-    pres.hDeviceWindow = hwnd;

-    pres.PresentationInterval = 1;

-    pres.Flags = 0;

-    hr = d3d9->CreateDevice(D3DADAPTER_DEFAULT,

-                            devType,

-                            hwnd, 

-                            D3DCREATE_HARDWARE_VERTEXPROCESSING, 

-                            &pres, 

-                            &d3d9Device);    

-    D3DERR_INVALIDCALL;

-    if (SUCCEEDED(hr)) {

-        d3d9Device->Clear(0, NULL, D3DCLEAR_TARGET, 0xFFFFFFFF, 0, 0);

-        return d3d9Device;

-    }

-    return NULL;

-}

-

-// This needs some improvement. D3D doesn't have the same notion of attach/detach

-// as GL. However, just allowing GDI to write to the window after creating the 

-// D3D device seems to work. 

-// We need to handle resizing. On XP and earlier Reset() will trash all our textures

-// so we would need to inform the SkGpu/caches or just recreate them. On Vista+ we

-// could use an IDirect3DDevice9Ex and call ResetEx() to resize without trashing

-// everything. Currently we do nothing and the D3D9 image gets stretched/compressed

-// when resized.

-

-bool SkOSWindow::attachD3D9() {

-    if (NULL == fD3D9Device) {

-        fD3D9Device = (void*) create_d3d9_device((HWND)fHWND);

-    }

-    if (NULL != fD3D9Device) {

-        ((IDirect3DDevice9*)fD3D9Device)->BeginScene();

-        return true;

-    }

-    return false;

-}

-

-void SkOSWindow::detachD3D9() {

-    if (NULL != fD3D9Device) {

-        ((IDirect3DDevice9*)fD3D9Device)->EndScene();

-    }

-}

-

-void SkOSWindow::presentD3D9() {

-    if (NULL != fD3D9Device) {

-        HRESULT hr;

-        hr = ((IDirect3DDevice9*)fD3D9Device)->EndScene();

-        SkASSERT(SUCCEEDED(hr));

-        hr = ((IDirect3DDevice9*)d3d9Device())->Present(NULL, NULL, NULL, NULL);

-        SkASSERT(SUCCEEDED(hr));

-        hr = ((IDirect3DDevice9*)fD3D9Device)->Clear(0,NULL,D3DCLEAR_TARGET | 

-                                                     D3DCLEAR_STENCIL, 0x0, 0, 

-                                                     0);

-        SkASSERT(SUCCEEDED(hr));

-        hr = ((IDirect3DDevice9*)fD3D9Device)->BeginScene();

-        SkASSERT(SUCCEEDED(hr));

-    }

-}

-

-// return true on success

-bool SkOSWindow::attach(SkBackEndTypes attachType) {

-

-    // 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; 

-    case kNativeGL_BackEndType:

-        result = attachGL();

-        break;

-#if SK_ANGLE

-    case kANGLE_BackEndType:

-        result = attachANGLE();

-        break;

-#endif

-    case kD3D9_BackEndType:

-        result = attachD3D9();

-        break;

-    default:

-        SkASSERT(false);

-        result = false;

-        break;

-    }

-

-    if (result) {

-        fAttached = attachType;

-    }

-

-    return result;

-}

-

-void SkOSWindow::detach() {

-    switch (fAttached) {

-    case kNone_BackEndType:

-        // nothing to do

-        break; 

-    case kNativeGL_BackEndType:

-        detachGL();

-        break;

-#if SK_ANGLE

-    case kANGLE_BackEndType:

-        detachANGLE();

-        break;

-#endif

-    case kD3D9_BackEndType:

-        detachD3D9();

-        break;

-    default:

-        SkASSERT(false);

-        break;

-    }

-    fAttached = kNone_BackEndType;

-}

-

-void SkOSWindow::present() {

-    switch (fAttached) {

-    case kNone_BackEndType:

-        // nothing to do

-        return; 

-    case kNativeGL_BackEndType:

-        presentGL();

-        break;

-#if SK_ANGLE

-    case kANGLE_BackEndType:

-        presentANGLE();

-        break;

-#endif

-    case kD3D9_BackEndType:

-        presentD3D9();

-        break;

-    default:

-        SkASSERT(false);

-        break;

-    }

-}

-

-#endif

-

+
+/*
+ * 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 <d3d9.h>
+#include <WindowsX.h>
+#include "SkWGL.h"
+#include "SkWindow.h"
+#include "SkCanvas.h"
+#include "SkOSMenu.h"
+#include "SkTime.h"
+#include "SkUtils.h"
+
+#include "SkGraphics.h"
+
+#if SK_ANGLE
+#include "GLES2/gl2.h"
+#endif
+
+#define INVALIDATE_DELAY_MS 200
+
+static SkOSWindow* gCurrOSWin;
+static HWND gEventTarget;
+
+#define WM_EVENT_CALLBACK (WM_USER+0)
+
+void post_skwinevent()
+{
+    PostMessage(gEventTarget, WM_EVENT_CALLBACK, 0, 0);
+}
+
+SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd) 
+#if SK_ANGLE
+                                     , fDisplay(EGL_NO_DISPLAY)
+                                     , fContext(EGL_NO_CONTEXT)
+                                     , fSurface(EGL_NO_SURFACE)
+#endif
+                                     , fHGLRC(NULL),
+                                     fGLAttached(false),
+                                     fD3D9Device(NULL),
+                                     fD3D9Attached(FALSE) {
+    gEventTarget = (HWND)hWnd;
+}
+
+SkOSWindow::~SkOSWindow() {
+    if (NULL != fD3D9Device) {
+        ((IDirect3DDevice9*)fD3D9Device)->Release();
+    }
+    if (NULL != fHGLRC) {
+        wglDeleteContext((HGLRC)fHGLRC);
+    }
+#if SK_ANGLE
+    if (EGL_NO_DISPLAY != fDisplay) {
+        angle::eglDestroyContext(fDisplay, fContext);
+    }
+#endif
+}
+
+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;
+}
+
+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(wParam);
+            return true; 
+        case WM_CHAR: {
+            this->handleChar(SkUTF8_ToUnichar((char*)&wParam));
+            return true;
+        } break;
+        case WM_SIZE:
+            this->resize(lParam & 0xFFFF, lParam >> 16);
+            break;
+        case WM_PAINT: {
+            PAINTSTRUCT ps;
+            HDC hdc = BeginPaint(hWnd, &ps);
+            this->doPaint(hdc);
+            EndPaint(hWnd, &ps);
+            return true;
+            } break;
+
+        case WM_TIMER: {
+            RECT* rect = (RECT*)wParam;
+            InvalidateRect(hWnd, rect, FALSE);
+            KillTimer(hWnd, (UINT_PTR)rect);
+            delete rect;
+            return true;
+        } break;
+    
+        case WM_LBUTTONDOWN: 
+            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kDown_State);
+            return true;
+                    
+        case WM_MOUSEMOVE:
+            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kMoved_State);
+            return true;
+
+        case WM_LBUTTONUP:
+            this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kUp_State);
+            return true;
+
+        case WM_EVENT_CALLBACK:
+            if (SkEvent::ProcessEvent()) {
+                post_skwinevent();
+            }
+            return true;
+    }
+    return false;
+}
+
+void SkOSWindow::doPaint(void* ctx) {
+    this->update(NULL);
+
+    if (!fGLAttached && !fD3D9Attached)
+    {
+        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 iRet = SetDIBitsToDevice(hdc,
+            0, 0,
+            bitmap.width(), bitmap.height(),
+            0, 0,
+            0, bitmap.height(),
+            bitmap.getPixels(),
+            &bmi,
+            DIB_RGB_COLORS);
+        bitmap.unlockPixels();
+    }
+}
+
+#if 0
+void SkOSWindow::updateSize()
+{
+    RECT    r;
+    GetWindowRect((HWND)this->getHWND(), &r);
+    this->resize(r.right - r.left, r.bottom - r.top);
+}
+#endif
+
+void SkOSWindow::onHandleInval(const SkIRect& r) {
+    RECT* rect = new RECT;
+    rect->left    = r.fLeft;
+    rect->top     = r.fTop;
+    rect->right   = r.fRight;
+    rect->bottom  = r.fBottom;
+    SetTimer((HWND)fHWND, (UINT_PTR)rect, INVALIDATE_DELAY_MS, NULL);
+}
+
+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()
+{
+    post_skwinevent();
+    //SkDebugf("signal nonempty\n");
+}
+
+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);
+    }
+}
+
+
+#define USE_MSAA 0
+
+HGLRC create_gl(HWND hwnd) {
+    HDC dc = GetDC(hwnd);
+    SkWGLExtensions extensions;
+    if (!extensions.hasExtension(dc, "WGL_ARB_pixel_format")) {
+        return NULL;
+    }
+
+    HDC prevDC = wglGetCurrentDC();
+    HGLRC prevGLRC = wglGetCurrentContext();
+    PIXELFORMATDESCRIPTOR pfd;
+
+    int format = 0;
+
+    GLint iattrs[] = {
+        SK_WGL_DRAW_TO_WINDOW, TRUE,
+        SK_WGL_DOUBLE_BUFFER, TRUE,
+        SK_WGL_ACCELERATION, SK_WGL_FULL_ACCELERATION,
+        SK_WGL_SUPPORT_OPENGL, TRUE,
+        SK_WGL_COLOR_BITS, 24,
+        SK_WGL_ALPHA_BITS, 8,
+        SK_WGL_STENCIL_BITS, 8,
+
+        // these must be kept last
+        SK_WGL_SAMPLE_BUFFERS, TRUE,
+        SK_WGL_SAMPLES, 0,
+        0,0
+    };
+    static const int kSampleBuffersValueIdx = SK_ARRAY_COUNT(iattrs) - 5;
+    static const int kSamplesValueIdx = SK_ARRAY_COUNT(iattrs) - 3;
+    if (USE_MSAA && extensions.hasExtension(dc, "WGL_ARB_multisample")) {
+        for (int samples = 16; samples > 1; --samples) {
+            
+            iattrs[kSamplesValueIdx] = samples;
+            GLfloat fattrs[] = {0,0};
+            GLuint num;
+            int formats[64];
+            extensions.choosePixelFormat(dc, iattrs, fattrs, 64, formats, &num);
+            num = min(num,64);
+            for (GLuint i = 0; i < num; ++i) {
+                DescribePixelFormat(dc, formats[i], sizeof(pfd), &pfd);
+                if (SetPixelFormat(dc, formats[i], &pfd)) {
+                    format = formats[i];
+                    break;
+                }
+            }
+        }
+    }
+    if (0 == format) {
+        iattrs[kSampleBuffersValueIdx-1] = iattrs[kSampleBuffersValueIdx] = 0;
+        iattrs[kSamplesValueIdx-1] = iattrs[kSamplesValueIdx] = 0;
+        GLfloat fattrs[] = {0,0};
+        GLuint num;
+        extensions.choosePixelFormat(dc, iattrs, fattrs, 1, &format, &num);
+        DescribePixelFormat(dc, format, sizeof(pfd), &pfd);
+        BOOL set = SetPixelFormat(dc, format, &pfd);
+        SkASSERT(TRUE == set);
+    }
+    
+    HGLRC glrc = wglCreateContext(dc);
+    SkASSERT(glrc);
+
+    wglMakeCurrent(prevDC, prevGLRC);
+    return glrc;
+}
+
+bool SkOSWindow::attachGL() {
+    if (NULL == fHGLRC) {
+        fHGLRC = create_gl((HWND)fHWND);
+        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(GetDC((HWND)fHWND), (HGLRC)fHGLRC)) {
+        glViewport(0, 0, SkScalarRound(this->width()),
+                   SkScalarRound(this->height()));
+        fGLAttached = true;
+        return true;
+    }
+    return false;
+}
+
+void SkOSWindow::detachGL() {
+    wglMakeCurrent(GetDC((HWND)fHWND), 0);
+    fGLAttached = false;
+}
+
+void SkOSWindow::presentGL() {
+    glFlush();
+    SwapBuffers(GetDC((HWND)fHWND));
+}
+
+#if SK_ANGLE
+bool create_ANGLE(EGLNativeWindowType hWnd, angle::EGLDisplay* eglDisplay,
+                  angle::EGLContext* eglContext, angle::EGLSurface* eglSurface) {
+    EGLint contextAttribs[] = { 
+        EGL_CONTEXT_CLIENT_VERSION, 2, 
+        EGL_NONE, EGL_NONE 
+    };
+    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
+    };
+    EGLint surfaceAttribList[] = {
+        EGL_NONE, EGL_NONE
+    };
+
+    angle::EGLDisplay display = angle::eglGetDisplay(GetDC(hWnd));
+    if (display == EGL_NO_DISPLAY ) {
+       return false;
+    }
+
+    // Initialize EGL
+    EGLint majorVersion, minorVersion;
+    if (!angle::eglInitialize(display, &majorVersion, &minorVersion)) {
+       return false;
+    }
+
+    EGLint numConfigs;
+    if (!angle::eglGetConfigs(display, NULL, 0, &numConfigs)) {
+       return false;
+    }
+
+    // Choose config
+    angle::EGLConfig config;
+    if (!angle::eglChooseConfig(display, configAttribList, 
+                                &config, 1, &numConfigs)) {
+       return false;
+    }
+
+    // Create a surface
+    angle::EGLSurface surface = angle::eglCreateWindowSurface(display, config, 
+                                                        (EGLNativeWindowType)hWnd, 
+                                                        surfaceAttribList);
+    if (surface == EGL_NO_SURFACE) {
+       return false;
+    }
+
+    // Create a GL context
+    angle::EGLContext context = angle::eglCreateContext(display, config, 
+                                                        EGL_NO_CONTEXT,
+                                                        contextAttribs );
+    if (context == EGL_NO_CONTEXT ) {
+       return false;
+    }   
+    
+    // Make the context current
+    if (!angle::eglMakeCurrent(display, surface, surface, context)) {
+       return false;
+    }
+    
+    *eglDisplay = display;
+    *eglContext = context;
+    *eglSurface = surface;
+    return true;
+}
+
+bool SkOSWindow::attachANGLE() {
+    if (EGL_NO_DISPLAY == fDisplay) {
+        bool bResult = create_ANGLE((HWND)fHWND, &fDisplay, &fContext, &fSurface);
+        if (false == bResult) {
+            return false;
+        }
+        angle::glClearStencil(0);
+        angle::glClearColor(0, 0, 0, 0);
+        angle::glStencilMask(0xffffffff);
+        angle::glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+    }
+    if (angle::eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
+        angle::glViewport(0, 0, SkScalarRound(this->width()),
+                   SkScalarRound(this->height()));
+        fGLAttached = true;
+        return true;
+    }
+    return false;
+}
+
+void SkOSWindow::detachANGLE() {
+    angle::eglMakeCurrent(fDisplay, EGL_NO_SURFACE , EGL_NO_SURFACE , EGL_NO_CONTEXT);
+    fGLAttached = false;
+}
+
+void SkOSWindow::presentANGLE() {
+    angle::glFlush();
+    angle::eglSwapBuffers(fDisplay, fSurface);
+}
+#endif
+
+IDirect3DDevice9* create_d3d9_device(HWND hwnd) {
+    HRESULT hr;
+
+    IDirect3D9* d3d9;
+    d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
+    if (NULL == d3d9) {
+        return NULL;
+    }
+    D3DDEVTYPE devType = D3DDEVTYPE_HAL;
+    //D3DDEVTYPE devType = D3DDEVTYPE_REF;
+    DWORD qLevels;
+    DWORD qLevelsDepth;
+    D3DMULTISAMPLE_TYPE type;
+    for (type = D3DMULTISAMPLE_16_SAMPLES; 
+         type >= D3DMULTISAMPLE_NONMASKABLE; --(*(DWORD*)&type)) {
+        hr = d3d9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, 
+                                              devType, D3DFMT_D24S8, TRUE,
+                                              type, &qLevels);
+        qLevels = (hr == D3D_OK) ? qLevels : 0;
+        hr = d3d9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT, 
+                                              devType, D3DFMT_A8R8G8B8, TRUE,
+                                              type, &qLevelsDepth);
+        qLevelsDepth = (hr == D3D_OK) ? qLevelsDepth : 0;
+        qLevels = min(qLevels,qLevelsDepth);
+        if (qLevels > 0) {
+            break;
+        }
+    }
+    qLevels = 0;
+    IDirect3DDevice9* d3d9Device;
+    D3DPRESENT_PARAMETERS pres;
+    memset(&pres, 0, sizeof(pres));
+    pres.EnableAutoDepthStencil = TRUE;
+    pres.AutoDepthStencilFormat = D3DFMT_D24S8;
+    pres.BackBufferCount = 2;
+    pres.BackBufferFormat = D3DFMT_A8R8G8B8;
+    pres.BackBufferHeight = 0;
+    pres.BackBufferWidth = 0;
+    if (qLevels > 0) {
+        pres.MultiSampleType = type;
+        pres.MultiSampleQuality = qLevels-1;
+    } else {
+        pres.MultiSampleType = D3DMULTISAMPLE_NONE;
+        pres.MultiSampleQuality = 0;
+    }
+    pres.SwapEffect = D3DSWAPEFFECT_DISCARD;
+    pres.Windowed = TRUE;
+    pres.hDeviceWindow = hwnd;
+    pres.PresentationInterval = 1;
+    pres.Flags = 0;
+    hr = d3d9->CreateDevice(D3DADAPTER_DEFAULT,
+                            devType,
+                            hwnd, 
+                            D3DCREATE_HARDWARE_VERTEXPROCESSING, 
+                            &pres, 
+                            &d3d9Device);    
+    D3DERR_INVALIDCALL;
+    if (SUCCEEDED(hr)) {
+        d3d9Device->Clear(0, NULL, D3DCLEAR_TARGET, 0xFFFFFFFF, 0, 0);
+        return d3d9Device;
+    }
+    return NULL;
+}
+
+// This needs some improvement. D3D doesn't have the same notion of attach/detach
+// as GL. However, just allowing GDI to write to the window after creating the 
+// D3D device seems to work. 
+// We need to handle resizing. On XP and earlier Reset() will trash all our textures
+// so we would need to inform the SkGpu/caches or just recreate them. On Vista+ we
+// could use an IDirect3DDevice9Ex and call ResetEx() to resize without trashing
+// everything. Currently we do nothing and the D3D9 image gets stretched/compressed
+// when resized.
+
+bool SkOSWindow::attachD3D9() {
+    if (NULL == fD3D9Device) {
+        fD3D9Device = (void*) create_d3d9_device((HWND)fHWND);
+    }
+    if (NULL != fD3D9Device) {
+        ((IDirect3DDevice9*)fD3D9Device)->BeginScene();
+        fD3D9Attached = true;
+    }
+    return fD3D9Attached;
+}
+
+void SkOSWindow::detachD3D9() {
+    if (NULL != fD3D9Device) {
+        ((IDirect3DDevice9*)fD3D9Device)->EndScene();
+    }
+    fD3D9Attached = false;
+}
+
+void SkOSWindow::presentD3D9() {
+    if (NULL != fD3D9Device) {
+        HRESULT hr;
+        hr = ((IDirect3DDevice9*)fD3D9Device)->EndScene();
+        SkASSERT(SUCCEEDED(hr));
+        hr = ((IDirect3DDevice9*)d3d9Device())->Present(NULL, NULL, NULL, NULL);
+        SkASSERT(SUCCEEDED(hr));
+        hr = ((IDirect3DDevice9*)fD3D9Device)->Clear(0,NULL,D3DCLEAR_TARGET | 
+                                                     D3DCLEAR_STENCIL, 0x0, 0, 
+                                                     0);
+        SkASSERT(SUCCEEDED(hr));
+        hr = ((IDirect3DDevice9*)fD3D9Device)->BeginScene();
+        SkASSERT(SUCCEEDED(hr));
+    }
+}
+
+
+#endif
+