/*

 * Copyright (C) 2006-2009 Google Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     * Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above

 * copyright notice, this list of conditions and the following disclaimer

 * in the documentation and/or other materials provided with the

 * distribution.

 *     * Neither the name of Google Inc. nor the names of its

 * contributors may be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "WebInputEventFactory.h"

#include "WebInputEvent.h"

#include <wtf/Assertions.h>

namespace WebKit {

static const unsigned long defaultScrollLinesPerWheelDelta = 3;

static const unsigned long defaultScrollCharsPerWheelDelta = 1;

// WebKeyboardEvent -----------------------------------------------------------

static bool isKeyPad(WPARAM wparam, LPARAM lparam)

{

    bool keypad = false;

    switch (wparam) {

    case VK_RETURN:

        keypad = (lparam >> 16) & KF_EXTENDED;

        break;

    case VK_INSERT:

    case VK_DELETE:

    case VK_HOME:

    case VK_END:

    case VK_PRIOR:

    case VK_NEXT:

    case VK_UP:

    case VK_DOWN:

    case VK_LEFT:

    case VK_RIGHT:

        keypad = !((lparam >> 16) & KF_EXTENDED);

        break;

    case VK_NUMLOCK:

    case VK_NUMPAD0:

    case VK_NUMPAD1:

    case VK_NUMPAD2:

    case VK_NUMPAD3:

    case VK_NUMPAD4:

    case VK_NUMPAD5:

    case VK_NUMPAD6:

    case VK_NUMPAD7:

    case VK_NUMPAD8:

    case VK_NUMPAD9:

    case VK_DIVIDE:

    case VK_MULTIPLY:

    case VK_SUBTRACT:

    case VK_ADD:

    case VK_DECIMAL:

    case VK_CLEAR:

        keypad = true;

        break;

    default:

        keypad = false;

    }

    return keypad;

}

WebKeyboardEvent WebInputEventFactory::keyboardEvent(HWND hwnd, UINT message,

                                                     WPARAM wparam, LPARAM lparam)

{

    WebKeyboardEvent result;

    // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that

    // GetMessageTime() refers to is the same one that we're passed in? Perhaps

    // one of the construction parameters should be the time passed by the

    // caller, who would know for sure.

    result.timeStampSeconds = GetMessageTime() / 1000.0;

    result.windowsKeyCode = result.nativeKeyCode = static_cast<int>(wparam);

    switch (message) {

    case WM_SYSKEYDOWN:

        result.isSystemKey = true;

    case WM_KEYDOWN:

        result.type = WebInputEvent::RawKeyDown;

        break;

    case WM_SYSKEYUP:

        result.isSystemKey = true;

    case WM_KEYUP:

        result.type = WebInputEvent::KeyUp;

        break;

    case WM_IME_CHAR:

        result.type = WebInputEvent::Char;

        break;

    case WM_SYSCHAR:

        result.isSystemKey = true;

        result.type = WebInputEvent::Char;

    case WM_CHAR:

        result.type = WebInputEvent::Char;

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    if (result.type == WebInputEvent::Char || result.type == WebInputEvent::RawKeyDown) {

        result.text[0] = result.windowsKeyCode;

        result.unmodifiedText[0] = result.windowsKeyCode;

    }

    if (result.type != WebInputEvent::Char)

        result.setKeyIdentifierFromWindowsKeyCode();

    if (GetKeyState(VK_SHIFT) & 0x8000)

        result.modifiers |= WebInputEvent::ShiftKey;

    if (GetKeyState(VK_CONTROL) & 0x8000)

        result.modifiers |= WebInputEvent::ControlKey;

    if (GetKeyState(VK_MENU) & 0x8000)

        result.modifiers |= WebInputEvent::AltKey;

    // NOTE: There doesn't seem to be a way to query the mouse button state in

    // this case.

    if (LOWORD(lparam) > 1)

        result.modifiers |= WebInputEvent::IsAutoRepeat;

    if (isKeyPad(wparam, lparam))

        result.modifiers |= WebInputEvent::IsKeyPad;

    return result;

}

// WebMouseEvent --------------------------------------------------------------

static int gLastClickCount;

static double gLastClickTime;

static LPARAM GetRelativeCursorPos(HWND hwnd)

{

    POINT pos = {-1, -1};

    GetCursorPos(&pos);

    ScreenToClient(hwnd, &pos);

    return MAKELPARAM(pos.x, pos.y);

}

void WebInputEventFactory::resetLastClickState()

{

    gLastClickTime = gLastClickCount = 0;

}

WebMouseEvent WebInputEventFactory::mouseEvent(HWND hwnd, UINT message,

                                               WPARAM wparam, LPARAM lparam)

{

    WebMouseEvent result; //(WebInputEvent::Uninitialized());

    switch (message) {

    case WM_MOUSEMOVE:

        result.type = WebInputEvent::MouseMove;

        if (wparam & MK_LBUTTON)

            result.button = WebMouseEvent::ButtonLeft;

        else if (wparam & MK_MBUTTON)

            result.button = WebMouseEvent::ButtonMiddle;

        else if (wparam & MK_RBUTTON)

            result.button = WebMouseEvent::ButtonRight;

        else

            result.button = WebMouseEvent::ButtonNone;

        break;

    case WM_MOUSELEAVE:

        result.type = WebInputEvent::MouseLeave;

        result.button = WebMouseEvent::ButtonNone;

        // set the current mouse position (relative to the client area of the

        // current window) since none is specified for this event

        lparam = GetRelativeCursorPos(hwnd);

        break;

    case WM_LBUTTONDOWN:

    case WM_LBUTTONDBLCLK:

        result.type = WebInputEvent::MouseDown;

        result.button = WebMouseEvent::ButtonLeft;

        break;

    case WM_MBUTTONDOWN:

    case WM_MBUTTONDBLCLK:

        result.type = WebInputEvent::MouseDown;

        result.button = WebMouseEvent::ButtonMiddle;

        break;

    case WM_RBUTTONDOWN:

    case WM_RBUTTONDBLCLK:

        result.type = WebInputEvent::MouseDown;

        result.button = WebMouseEvent::ButtonRight;

        break;

    case WM_LBUTTONUP:

        result.type = WebInputEvent::MouseUp;

        result.button = WebMouseEvent::ButtonLeft;

        break;

    case WM_MBUTTONUP:

        result.type = WebInputEvent::MouseUp;

        result.button = WebMouseEvent::ButtonMiddle;

        break;

    case WM_RBUTTONUP:

        result.type = WebInputEvent::MouseUp;

        result.button = WebMouseEvent::ButtonRight;

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that

    // GetMessageTime() refers to is the same one that we're passed in? Perhaps

    // one of the construction parameters should be the time passed by the

    // caller, who would know for sure.

    result.timeStampSeconds = GetMessageTime() / 1000.0;

    // set position fields:

    result.x = static_cast<short>(LOWORD(lparam));

    result.y = static_cast<short>(HIWORD(lparam));

    result.windowX = result.x;

    result.windowY = result.y;

    POINT globalPoint = { result.x, result.y };

    ClientToScreen(hwnd, &globalPoint);

    result.globalX = globalPoint.x;

    result.globalY = globalPoint.y;

    // calculate number of clicks:

    // This differs slightly from the WebKit code in WebKit/win/WebView.cpp

    // where their original code looks buggy.

    static int lastClickPositionX;

    static int lastClickPositionY;

    static WebMouseEvent::Button lastClickButton = WebMouseEvent::ButtonLeft;

    double currentTime = result.timeStampSeconds;

    bool cancelPreviousClick =

        (abs(lastClickPositionX - result.x) > (GetSystemMetrics(SM_CXDOUBLECLK) / 2))

        || (abs(lastClickPositionY - result.y) > (GetSystemMetrics(SM_CYDOUBLECLK) / 2))

        || ((currentTime - gLastClickTime) * 1000.0 > GetDoubleClickTime());

    if (result.type == WebInputEvent::MouseDown) {

        if (!cancelPreviousClick && (result.button == lastClickButton))

            ++gLastClickCount;

        else {

            gLastClickCount = 1;

            lastClickPositionX = result.x;

            lastClickPositionY = result.y;

        }

        gLastClickTime = currentTime;

        lastClickButton = result.button;

    } else if (result.type == WebInputEvent::MouseMove

               || result.type == WebInputEvent::MouseLeave) {

        if (cancelPreviousClick) {

            gLastClickCount = 0;

            lastClickPositionX = 0;

            lastClickPositionY = 0;

            gLastClickTime = 0;

        }

    }

    result.clickCount = gLastClickCount;

    // set modifiers:

    if (wparam & MK_CONTROL)

        result.modifiers |= WebInputEvent::ControlKey;

    if (wparam & MK_SHIFT)

        result.modifiers |= WebInputEvent::ShiftKey;

    if (GetKeyState(VK_MENU) & 0x8000)

        result.modifiers |= WebInputEvent::AltKey;

    if (wparam & MK_LBUTTON)

        result.modifiers |= WebInputEvent::LeftButtonDown;

    if (wparam & MK_MBUTTON)

        result.modifiers |= WebInputEvent::MiddleButtonDown;

    if (wparam & MK_RBUTTON)

        result.modifiers |= WebInputEvent::RightButtonDown;

    return result;

}

// WebMouseWheelEvent ---------------------------------------------------------

WebMouseWheelEvent WebInputEventFactory::mouseWheelEvent(HWND hwnd, UINT message,

                                                         WPARAM wparam, LPARAM lparam)

{

    WebMouseWheelEvent result; //(WebInputEvent::Uninitialized());

    result.type = WebInputEvent::MouseWheel;

    // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that

    // GetMessageTime() refers to is the same one that we're passed in? Perhaps

    // one of the construction parameters should be the time passed by the

    // caller, who would know for sure.

    result.timeStampSeconds = GetMessageTime() / 1000.0;

    result.button = WebMouseEvent::ButtonNone;

    // Get key state, coordinates, and wheel delta from event.

    typedef SHORT (WINAPI *GetKeyStateFunction)(int key);

    GetKeyStateFunction getKeyState;

    UINT keyState;

    float wheelDelta;

    bool horizontalScroll = false;

    if ((message == WM_VSCROLL) || (message == WM_HSCROLL)) {

        // Synthesize mousewheel event from a scroll event.  This is needed to

        // simulate middle mouse scrolling in some laptops.  Use GetAsyncKeyState

        // for key state since we are synthesizing the input event.

        getKeyState = GetAsyncKeyState;

        keyState = 0;

        if (getKeyState(VK_SHIFT))

            keyState |= MK_SHIFT;

        if (getKeyState(VK_CONTROL))

            keyState |= MK_CONTROL;

        // NOTE: There doesn't seem to be a way to query the mouse button state

        // in this case.

        POINT cursorPosition = {0};

        GetCursorPos(&cursorPosition);

        result.globalX = cursorPosition.x;

        result.globalY = cursorPosition.y;

        switch (LOWORD(wparam)) {

        case SB_LINEUP:    // == SB_LINELEFT

            wheelDelta = WHEEL_DELTA;

            break;

        case SB_LINEDOWN:  // == SB_LINERIGHT

            wheelDelta = -WHEEL_DELTA;

            break;

        case SB_PAGEUP:

            wheelDelta = 1;

            result.scrollByPage = true;

            break;

        case SB_PAGEDOWN:

            wheelDelta = -1;

            result.scrollByPage = true;

            break;

        default:  // We don't supoprt SB_THUMBPOSITION or SB_THUMBTRACK here.

            wheelDelta = 0;

            break;

        }

        if (message == WM_HSCROLL)

            horizontalScroll = true;

    } else {

        // Non-synthesized event; we can just read data off the event.

        getKeyState = GetKeyState;

        keyState = GET_KEYSTATE_WPARAM(wparam);

        result.globalX = static_cast<short>(LOWORD(lparam));

        result.globalY = static_cast<short>(HIWORD(lparam));

        wheelDelta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wparam));

        if (message == WM_MOUSEHWHEEL) {

            horizontalScroll = true;

            wheelDelta = -wheelDelta;  // Windows is <- -/+ ->, WebKit <- +/- ->.

        }

    }

    if (keyState & MK_SHIFT)

        horizontalScroll = true;

    // Set modifiers based on key state.

    if (keyState & MK_SHIFT)

        result.modifiers |= WebInputEvent::ShiftKey;

    if (keyState & MK_CONTROL)

        result.modifiers |= WebInputEvent::ControlKey;

    if (getKeyState(VK_MENU) & 0x8000)

        result.modifiers |= WebInputEvent::AltKey;

    if (keyState & MK_LBUTTON)

        result.modifiers |= WebInputEvent::LeftButtonDown;

    if (keyState & MK_MBUTTON)

        result.modifiers |= WebInputEvent::MiddleButtonDown;

    if (keyState & MK_RBUTTON)

        result.modifiers |= WebInputEvent::RightButtonDown;

    // Set coordinates by translating event coordinates from screen to client.

    POINT clientPoint = { result.globalX, result.globalY };

    MapWindowPoints(0, hwnd, &clientPoint, 1);

    result.x = clientPoint.x;

    result.y = clientPoint.y;

    result.windowX = result.x;

    result.windowY = result.y;

    // Convert wheel delta amount to a number of pixels to scroll.

    //

    // How many pixels should we scroll per line?  Gecko uses the height of the

    // current line, which means scroll distance changes as you go through the

    // page or go to different pages.  IE 7 is ~50 px/line, although the value

    // seems to vary slightly by page and zoom level.  Since IE 7 has a smoothing

    // algorithm on scrolling, it can get away with slightly larger scroll values

    // without feeling jerky.  Here we use 100 px per three lines (the default

    // scroll amount is three lines per wheel tick).

    static const float scrollbarPixelsPerLine = 100.0f / 3.0f;

    wheelDelta /= WHEEL_DELTA;

    float scrollDelta = wheelDelta;

    if (horizontalScroll) {

        unsigned long scrollChars = defaultScrollCharsPerWheelDelta;

        SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &scrollChars, 0);

        // TODO(pkasting): Should probably have a different multiplier

        // scrollbarPixelsPerChar here.

        scrollDelta *= static_cast<float>(scrollChars) * scrollbarPixelsPerLine;

    } else {

        unsigned long scrollLines = defaultScrollLinesPerWheelDelta;

        SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &scrollLines, 0);

        if (scrollLines == WHEEL_PAGESCROLL)

            result.scrollByPage = true;

        if (!result.scrollByPage)

            scrollDelta *= static_cast<float>(scrollLines) * scrollbarPixelsPerLine;

    }

    // Set scroll amount based on above calculations.  WebKit expects positive

    // deltaY to mean "scroll up" and positive deltaX to mean "scroll left".

    if (horizontalScroll) {

        result.deltaX = scrollDelta;

        result.wheelTicksX = wheelDelta;

    } else {

        result.deltaY = scrollDelta;

        result.wheelTicksY = wheelDelta;

    }

    return result;

}

} // namespace WebKit