text: /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  /* vim: set ts=2 et sw=2 tw=80: */
  /* This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   * You can obtain one at http://mozilla.org/MPL/2.0/. */
  
  #ifdef MOZ_LOGGING
  #define FORCE_PR_LOG /* Allow logging in the release build */
  #endif // MOZ_LOGGING
  #include "prlog.h"
  
  #include "WinMouseScrollHandler.h"
  #include "nsWindow.h"
  #include "KeyboardLayout.h"
  #include "WinUtils.h"
  #include "nsGkAtoms.h"
  #include "nsIDOMWindowUtils.h"
  #include "nsIDOMWheelEvent.h"
  
  #include "mozilla/Preferences.h"
  
  #include <psapi.h>
  
  namespace mozilla {
  namespace widget {
  
  #ifdef PR_LOGGING
  PRLogModuleInfo* gMouseScrollLog = nullptr;
  
  static const char* GetBoolName(bool aBool)
  {
    return aBool ? "TRUE" : "FALSE";
  }
  
  static void LogKeyStateImpl()
  {
    if (!PR_LOG_TEST(gMouseScrollLog, PR_LOG_DEBUG)) {
      return;
    }
    BYTE keyboardState[256];
    if (::GetKeyboardState(keyboardState)) {
      for (size_t i = 0; i < ArrayLength(keyboardState); i++) {
        if (keyboardState[i]) {
          PR_LOG(gMouseScrollLog, PR_LOG_DEBUG,
            ("    Current key state: keyboardState[0x%02X]=0x%02X (%s)",
             i, keyboardState[i],
             ((keyboardState[i] & 0x81) == 0x81) ? "Pressed and Toggled" :
             (keyboardState[i] & 0x80) ? "Pressed" :
             (keyboardState[i] & 0x01) ? "Toggled" : "Unknown"));
        }
      }
    } else {
      PR_LOG(gMouseScrollLog, PR_LOG_DEBUG,
        ("MouseScroll::Device::Elantech::HandleKeyMessage(): Failed to print "
         "current keyboard state"));
    }
  }
  
  #define LOG_KEYSTATE() LogKeyStateImpl()
  #else // PR_LOGGING
  #define LOG_KEYSTATE()
  #endif
  
  MouseScrollHandler* MouseScrollHandler::sInstance = nullptr;
  
  bool MouseScrollHandler::Device::sFakeScrollableWindowNeeded = false;
  
  bool MouseScrollHandler::Device::Elantech::sUseSwipeHack = false;
  bool MouseScrollHandler::Device::Elantech::sUsePinchHack = false;
  DWORD MouseScrollHandler::Device::Elantech::sZoomUntil = 0;
  
  bool MouseScrollHandler::Device::SetPoint::sMightBeUsing = false;
  
  // The duration until timeout of events transaction.  The value is 1.5 sec,
  // it's just a magic number, it was suggested by Logitech's engineer, see
  // bug 605648 comment 90.
  #define DEFAULT_TIMEOUT_DURATION 1500
  
  /******************************************************************************
   *
   * MouseScrollHandler
   *
   ******************************************************************************/
  
  /* static */
  POINTS
  MouseScrollHandler::GetCurrentMessagePos()
  {
    if (SynthesizingEvent::IsSynthesizing()) {
      return sInstance->mSynthesizingEvent->GetCursorPoint();
    }
    DWORD pos = ::GetMessagePos();
    return MAKEPOINTS(pos);
  }
  
  // Get rid of the GetMessagePos() API.
  #define GetMessagePos()
  
  /* static */
  void
  MouseScrollHandler::Initialize()
  {
  #ifdef PR_LOGGING
    if (!gMouseScrollLog) {
      gMouseScrollLog = PR_NewLogModule("MouseScrollHandlerWidgets");
    }
  #endif
    Device::Init();
  }
  
  /* static */
  void
  MouseScrollHandler::Shutdown()
  {
    delete sInstance;
    sInstance = nullptr;
  }
  
  /* static */
  MouseScrollHandler*
  MouseScrollHandler::GetInstance()
  {
    if (!sInstance) {
      sInstance = new MouseScrollHandler();
    }
    return sInstance;
  }
  
  MouseScrollHandler::MouseScrollHandler() :
    mIsWaitingInternalMessage(false),
    mSynthesizingEvent(nullptr)
  {
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll: Creating an instance, this=%p, sInstance=%p",
       this, sInstance));
  }
  
  MouseScrollHandler::~MouseScrollHandler()
  {
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll: Destroying an instance, this=%p, sInstance=%p",
       this, sInstance));
  
    delete mSynthesizingEvent;
  }
  
  /* static */
  bool
  MouseScrollHandler::ProcessMessage(nsWindow* aWindow, UINT msg,
                                     WPARAM wParam, LPARAM lParam,
                                     LRESULT *aRetValue, bool &aEatMessage)
  {
    Device::Elantech::UpdateZoomUntil();
  
    switch (msg) {
      case WM_SETTINGCHANGE:
        if (!sInstance) {
          return false;
        }
        if (wParam == SPI_SETWHEELSCROLLLINES ||
            wParam == SPI_SETWHEELSCROLLCHARS) {
          sInstance->mSystemSettings.MarkDirty();
        }
        return false;
  
      case WM_MOUSEWHEEL:
      case WM_MOUSEHWHEEL:
        GetInstance()->
          ProcessNativeMouseWheelMessage(aWindow, msg, wParam, lParam);
        sInstance->mSynthesizingEvent->NotifyNativeMessageHandlingFinished();
        // We don't need to call next wndproc for WM_MOUSEWHEEL and
        // WM_MOUSEHWHEEL.  We should consume them always.  If the messages
        // would be handled by our window again, it caused making infinite
        // message loop.
        aEatMessage = true;
        *aRetValue = (msg != WM_MOUSEHWHEEL);
        return true;
  
      case WM_HSCROLL:
      case WM_VSCROLL:
        aEatMessage =
          GetInstance()->ProcessNativeScrollMessage(aWindow, msg, wParam, lParam);
        sInstance->mSynthesizingEvent->NotifyNativeMessageHandlingFinished();
        *aRetValue = 0;
        return true;
  
      case MOZ_WM_MOUSEVWHEEL:
      case MOZ_WM_MOUSEHWHEEL:
        GetInstance()->HandleMouseWheelMessage(aWindow, msg, wParam, lParam);
        sInstance->mSynthesizingEvent->NotifyInternalMessageHandlingFinished();
        // Doesn't need to call next wndproc for internal wheel message.
        aEatMessage = true;
        return true;
  
      case MOZ_WM_HSCROLL:
      case MOZ_WM_VSCROLL:
        GetInstance()->
          HandleScrollMessageAsMouseWheelMessage(aWindow, msg, wParam, lParam);
        sInstance->mSynthesizingEvent->NotifyInternalMessageHandlingFinished();
        // Doesn't need to call next wndproc for internal scroll message.
        aEatMessage = true;
        return true;
  
      case WM_KEYDOWN:
      case WM_KEYUP:
        PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
          ("MouseScroll::ProcessMessage(): aWindow=%p, "
           "msg=%s(0x%04X), wParam=0x%02X, ::GetMessageTime()=%d",
           aWindow, msg == WM_KEYDOWN ? "WM_KEYDOWN" :
                      msg == WM_KEYUP ? "WM_KEYUP" : "Unknown", msg, wParam,
           ::GetMessageTime()));
        LOG_KEYSTATE();
        if (Device::Elantech::HandleKeyMessage(aWindow, msg, wParam)) {
          *aRetValue = 0;
          aEatMessage = true;
          return true;
        }
        return false;
  
      default:
        return false;
    }
  }
  
  /* static */
  nsresult
  MouseScrollHandler::SynthesizeNativeMouseScrollEvent(nsWindow* aWindow,
                                                       const nsIntPoint& aPoint,
                                                       uint32_t aNativeMessage,
                                                       int32_t aDelta,
                                                       uint32_t aModifierFlags,
                                                       uint32_t aAdditionalFlags)
  {
    bool useFocusedWindow =
      !(aAdditionalFlags & nsIDOMWindowUtils::MOUSESCROLL_PREFER_WIDGET_AT_POINT);
  
    POINT pt;
    pt.x = aPoint.x;
    pt.y = aPoint.y;
  
    HWND target = useFocusedWindow ? ::WindowFromPoint(pt) : ::GetFocus();
    NS_ENSURE_TRUE(target, NS_ERROR_FAILURE);
  
    WPARAM wParam = 0;
    LPARAM lParam = 0;
    switch (aNativeMessage) {
      case WM_MOUSEWHEEL:
      case WM_MOUSEHWHEEL: {
        lParam = MAKELPARAM(pt.x, pt.y);
        WORD mod = 0;
        if (aModifierFlags & (nsIWidget::CTRL_L | nsIWidget::CTRL_R)) {
          mod |= MK_CONTROL;
        }
        if (aModifierFlags & (nsIWidget::SHIFT_L | nsIWidget::SHIFT_R)) {
          mod |= MK_SHIFT;
        }
        wParam = MAKEWPARAM(mod, aDelta);
        break;
      }
      case WM_VSCROLL:
      case WM_HSCROLL:
        lParam = (aAdditionalFlags &
                    nsIDOMWindowUtils::MOUSESCROLL_WIN_SCROLL_LPARAM_NOT_NULL) ?
          reinterpret_cast<LPARAM>(target) : 0;
        wParam = aDelta;
        break;
      default:
        return NS_ERROR_INVALID_ARG;
    }
  
    // Ensure to make the instance.
    GetInstance();
  
    BYTE kbdState[256];
    memset(kbdState, 0, sizeof(kbdState));
  
    nsAutoTArray<KeyPair,10> keySequence;
    nsWindow::SetupKeyModifiersSequence(&keySequence, aModifierFlags);
  
    for (uint32_t i = 0; i < keySequence.Length(); ++i) {
      uint8_t key = keySequence[i].mGeneral;
      uint8_t keySpecific = keySequence[i].mSpecific;
      kbdState[key] = 0x81; // key is down and toggled on if appropriate
      if (keySpecific) {
        kbdState[keySpecific] = 0x81;
      }
    }
  
    if (!sInstance->mSynthesizingEvent) {
      sInstance->mSynthesizingEvent = new SynthesizingEvent();
    }
  
    POINTS pts;
    pts.x = static_cast<SHORT>(pt.x);
    pts.y = static_cast<SHORT>(pt.y);
    return sInstance->mSynthesizingEvent->
             Synthesize(pts, target, aNativeMessage, wParam, lParam, kbdState);
  }
  
  /* static */
  bool
  MouseScrollHandler::DispatchEvent(nsWindow* aWindow, nsGUIEvent& aEvent)
  {
    return aWindow->DispatchWindowEvent(&aEvent);
  }
  
  /* static */
  void
  MouseScrollHandler::InitEvent(nsWindow* aWindow,
                                nsGUIEvent& aEvent,
                                nsIntPoint* aPoint)
  {
    NS_ENSURE_TRUE_VOID(aWindow);
    nsIntPoint point;
    if (aPoint) {
      point = *aPoint;
    } else {
      POINTS pts = GetCurrentMessagePos();
      POINT pt;
      pt.x = pts.x;
      pt.y = pts.y;
      ::ScreenToClient(aWindow->GetWindowHandle(), &pt);
      point.x = pt.x;
      point.y = pt.y;
    }
    aWindow->InitEvent(aEvent, &point);
  }
  
  /* static */
  ModifierKeyState
  MouseScrollHandler::GetModifierKeyState(UINT aMessage)
  {
    ModifierKeyState result;
    // Assume the Control key is down if the Elantech touchpad has sent the
    // mis-ordered WM_KEYDOWN/WM_MOUSEWHEEL messages.  (See the comment in
    // MouseScrollHandler::Device::Elantech::HandleKeyMessage().)
    if ((aMessage == MOZ_WM_MOUSEVWHEEL || aMessage == WM_MOUSEWHEEL) &&
        !result.IsControl() && Device::Elantech::IsZooming()) {
      result.Set(MODIFIER_CONTROL);
    }
    return result;
  }
  
  POINT
  MouseScrollHandler::ComputeMessagePos(UINT aMessage,
                                        WPARAM aWParam,
                                        LPARAM aLParam)
  {
    POINT point;
    if (Device::SetPoint::IsGetMessagePosResponseValid(aMessage,
                                                       aWParam, aLParam)) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::ComputeMessagePos: Using ::GetCursorPos()"));
      ::GetCursorPos(&point);
    } else {
      POINTS pts = GetCurrentMessagePos();
      point.x = pts.x;
      point.y = pts.y;
    }
    return point;
  }
  
  void
  MouseScrollHandler::ProcessNativeMouseWheelMessage(nsWindow* aWindow,
                                                     UINT aMessage,
                                                     WPARAM aWParam,
                                                     LPARAM aLParam)
  {
    if (SynthesizingEvent::IsSynthesizing()) {
      mSynthesizingEvent->NativeMessageReceived(aWindow, aMessage,
                                                aWParam, aLParam);
    }
  
    POINT point = ComputeMessagePos(aMessage, aWParam, aLParam);
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::ProcessNativeMouseWheelMessage: aWindow=%p, "
       "aMessage=%s, wParam=0x%08X, lParam=0x%08X, point: { x=%d, y=%d }",
       aWindow, aMessage == WM_MOUSEWHEEL ? "WM_MOUSEWHEEL" :
                aMessage == WM_MOUSEHWHEEL ? "WM_MOUSEHWHEEL" :
                aMessage == WM_VSCROLL ? "WM_VSCROLL" : "WM_HSCROLL",
       aWParam, aLParam, point.x, point.y));
    LOG_KEYSTATE();
  
    HWND underCursorWnd = ::WindowFromPoint(point);
    if (!underCursorWnd) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::ProcessNativeMouseWheelMessage: "
         "No window is not found under the cursor"));
      return;
    }
  
    if (Device::Elantech::IsPinchHackNeeded() &&
        Device::Elantech::IsHelperWindow(underCursorWnd)) {
      // The Elantech driver places a window right underneath the cursor
      // when sending a WM_MOUSEWHEEL event to us as part of a pinch-to-zoom
      // gesture.  We detect that here, and search for our window that would
      // be beneath the cursor if that window wasn't there.
      underCursorWnd = WinUtils::FindOurWindowAtPoint(point);
      if (!underCursorWnd) {
        PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
          ("MouseScroll::ProcessNativeMouseWheelMessage: "
           "Our window is not found under the Elantech helper window"));
        return;
      }
    }
  
    // Handle most cases first.  If the window under mouse cursor is our window
    // except plugin window (MozillaWindowClass), we should handle the message
    // on the window.
    if (WinUtils::IsOurProcessWindow(underCursorWnd)) {
      nsWindow* destWindow = WinUtils::GetNSWindowPtr(underCursorWnd);
      if (!destWindow) {
        PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
          ("MouseScroll::ProcessNativeMouseWheelMessage: "
           "Found window under the cursor isn't managed by nsWindow..."));
        HWND wnd = ::GetParent(underCursorWnd);
        for (; wnd; wnd = ::GetParent(wnd)) {
          destWindow = WinUtils::GetNSWindowPtr(wnd);
          if (destWindow) {
            break;
          }
        }
        if (!wnd) {
          PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
            ("MouseScroll::ProcessNativeMouseWheelMessage: Our window which is "
             "managed by nsWindow is not found under the cursor"));
          return;
        }
      }
  
      MOZ_ASSERT(destWindow, "destWindow must not be NULL");
  
      // If the found window is our plugin window, it means that the message
      // has been handled by the plugin but not consumed.  We should handle the
      // message on its parent window.  However, note that the DOM event may
      // cause accessing the plugin.  Therefore, we should unlock the plugin
      // process by using PostMessage().
      if (destWindow->GetWindowType() == eWindowType_plugin) {
        destWindow = destWindow->GetParentWindow(false);
        if (!destWindow) {
          PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
            ("MouseScroll::ProcessNativeMouseWheelMessage: "
             "Our window which is a parent of a plugin window is not found"));
          return;
        }
      }
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::ProcessNativeMouseWheelMessage: Succeeded, "
         "Posting internal message to an nsWindow (%p)...",
         destWindow));
      mIsWaitingInternalMessage = true;
      UINT internalMessage = WinUtils::GetInternalMessage(aMessage);
      ::PostMessage(destWindow->GetWindowHandle(), internalMessage,
                    aWParam, aLParam);
      return;
    }
  
    // If the window under cursor is not in our process, it means:
    // 1. The window may be a plugin window (GeckoPluginWindow or its descendant).
    // 2. The window may be another application's window.
    HWND pluginWnd = WinUtils::FindOurProcessWindow(underCursorWnd);
    if (!pluginWnd) {
      // If there is no plugin window in ancestors of the window under cursor,
      // the window is for another applications (case 2).
      // We don't need to handle this message.
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::ProcessNativeMouseWheelMessage: "
         "Our window is not found under the cursor"));
      return;
    }
  
    // If we're a plugin window (MozillaWindowClass) and cursor in this window,
    // the message shouldn't go to plugin's wndproc again.  So, we should handle
    // it on parent window.  However, note that the DOM event may cause accessing
    // the plugin.  Therefore, we should unlock the plugin process by using
    // PostMessage().
    if (aWindow->GetWindowType() == eWindowType_plugin &&
        aWindow->GetWindowHandle() == pluginWnd) {
      nsWindow* destWindow = aWindow->GetParentWindow(false);
      if (!destWindow) {
        PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
          ("MouseScroll::ProcessNativeMouseWheelMessage: Our normal window which "
           "is a parent of this plugin window is not found"));
        return;
      }
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::ProcessNativeMouseWheelMessage: Succeeded, "
         "Posting internal message to an nsWindow (%p) which is parent of this "
         "plugin window...",
         destWindow));
      mIsWaitingInternalMessage = true;
      UINT internalMessage = WinUtils::GetInternalMessage(aMessage);
      ::PostMessage(destWindow->GetWindowHandle(), internalMessage,
                    aWParam, aLParam);
      return;
    }
  
    // If the window is a part of plugin, we should post the message to it.
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::ProcessNativeMouseWheelMessage: Succeeded, "
       "Redirecting the message to a window which is a plugin child window"));
    ::PostMessage(underCursorWnd, aMessage, aWParam, aLParam);
  }
  
  bool
  MouseScrollHandler::ProcessNativeScrollMessage(nsWindow* aWindow,
                                                 UINT aMessage,
                                                 WPARAM aWParam,
                                                 LPARAM aLParam)
  {
    if (aLParam || mUserPrefs.IsScrollMessageHandledAsWheelMessage()) {
      // Scroll message generated by Thinkpad Trackpoint Driver or similar
      // Treat as a mousewheel message and scroll appropriately
      ProcessNativeMouseWheelMessage(aWindow, aMessage, aWParam, aLParam);
      // Always consume the scroll message if we try to emulate mouse wheel
      // action.
      return true;
    }
  
    if (SynthesizingEvent::IsSynthesizing()) {
      mSynthesizingEvent->NativeMessageReceived(aWindow, aMessage,
                                                aWParam, aLParam);
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::ProcessNativeScrollMessage: aWindow=%p, "
       "aMessage=%s, wParam=0x%08X, lParam=0x%08X",
       aWindow, aMessage == WM_VSCROLL ? "WM_VSCROLL" : "WM_HSCROLL",
       aWParam, aLParam));
  
    // Scroll message generated by external application
    nsContentCommandEvent commandEvent(true, NS_CONTENT_COMMAND_SCROLL, aWindow);
  
    commandEvent.mScroll.mIsHorizontal = (aMessage == WM_HSCROLL);
  
    switch (LOWORD(aWParam)) {
      case SB_LINEUP:   // SB_LINELEFT
        commandEvent.mScroll.mUnit = nsContentCommandEvent::eCmdScrollUnit_Line;
        commandEvent.mScroll.mAmount = -1;
        break;
      case SB_LINEDOWN: // SB_LINERIGHT
        commandEvent.mScroll.mUnit = nsContentCommandEvent::eCmdScrollUnit_Line;
        commandEvent.mScroll.mAmount = 1;
        break;
      case SB_PAGEUP:   // SB_PAGELEFT
        commandEvent.mScroll.mUnit = nsContentCommandEvent::eCmdScrollUnit_Page;
        commandEvent.mScroll.mAmount = -1;
        break;
      case SB_PAGEDOWN: // SB_PAGERIGHT
        commandEvent.mScroll.mUnit = nsContentCommandEvent::eCmdScrollUnit_Page;
        commandEvent.mScroll.mAmount = 1;
        break;
      case SB_TOP:      // SB_LEFT
        commandEvent.mScroll.mUnit = nsContentCommandEvent::eCmdScrollUnit_Whole;
        commandEvent.mScroll.mAmount = -1;
        break;
      case SB_BOTTOM:   // SB_RIGHT
        commandEvent.mScroll.mUnit = nsContentCommandEvent::eCmdScrollUnit_Whole;
        commandEvent.mScroll.mAmount = 1;
        break;
      default:
        return false;
    }
    // XXX If this is a plugin window, we should dispatch the event from
    //     parent window.
    DispatchEvent(aWindow, commandEvent);
    return true;
  }
  
  void
  MouseScrollHandler::HandleMouseWheelMessage(nsWindow* aWindow,
                                              UINT aMessage,
                                              WPARAM aWParam,
                                              LPARAM aLParam)
  {
    NS_ABORT_IF_FALSE(
      (aMessage == MOZ_WM_MOUSEVWHEEL || aMessage == MOZ_WM_MOUSEHWHEEL),
      "HandleMouseWheelMessage must be called with "
      "MOZ_WM_MOUSEVWHEEL or MOZ_WM_MOUSEHWHEEL");
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::HandleMouseWheelMessage: aWindow=%p, "
       "aMessage=MOZ_WM_MOUSE%sWHEEL, aWParam=0x%08X, aLParam=0x%08X",
       aWindow, aMessage == MOZ_WM_MOUSEVWHEEL ? "V" : "H",
       aWParam, aLParam));
  
    mIsWaitingInternalMessage = false;
  
    EventInfo eventInfo(aWindow, WinUtils::GetNativeMessage(aMessage),
                        aWParam, aLParam);
    if (!eventInfo.CanDispatchWheelEvent()) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::HandleMouseWheelMessage: Cannot dispatch the events"));
      mLastEventInfo.ResetTransaction();
      return;
    }
  
    // Discard the remaining delta if current wheel message and last one are
    // received by different window or to scroll different direction or
    // different unit scroll.  Furthermore, if the last event was too old.
    if (!mLastEventInfo.CanContinueTransaction(eventInfo)) {
      mLastEventInfo.ResetTransaction();
    }
  
    mLastEventInfo.RecordEvent(eventInfo);
  
    ModifierKeyState modKeyState = GetModifierKeyState(aMessage);
  
    // Grab the widget, it might be destroyed by a DOM event handler.
    nsRefPtr<nsWindow> kungFuDethGrip(aWindow);
  
    WheelEvent wheelEvent(true, NS_WHEEL_WHEEL, aWindow);
    if (mLastEventInfo.InitWheelEvent(aWindow, wheelEvent, modKeyState)) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::HandleMouseWheelMessage: dispatching "
         "NS_WHEEL_WHEEL event"));
      DispatchEvent(aWindow, wheelEvent);
      if (aWindow->Destroyed()) {
        PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
          ("MouseScroll::HandleMouseWheelMessage: The window was destroyed "
           "by NS_WHEEL_WHEEL event"));
        mLastEventInfo.ResetTransaction();
        return;
      }
    }
  #ifdef PR_LOGGING
    else {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::HandleMouseWheelMessage: NS_WHEEL_WHEEL event is not "
         "dispatched"));
    }
  #endif
  }
  
  void
  MouseScrollHandler::HandleScrollMessageAsMouseWheelMessage(nsWindow* aWindow,
                                                             UINT aMessage,
                                                             WPARAM aWParam,
                                                             LPARAM aLParam)
  {
    NS_ABORT_IF_FALSE(
      (aMessage == MOZ_WM_VSCROLL || aMessage == MOZ_WM_HSCROLL),
      "HandleScrollMessageAsMouseWheelMessage must be called with "
      "MOZ_WM_VSCROLL or MOZ_WM_HSCROLL");
  
    mIsWaitingInternalMessage = false;
  
    ModifierKeyState modKeyState = GetModifierKeyState(aMessage);
  
    WheelEvent wheelEvent(true, NS_WHEEL_WHEEL, aWindow);
    double& delta =
     (aMessage == MOZ_WM_VSCROLL) ? wheelEvent.deltaY : wheelEvent.deltaX;
    int32_t& lineOrPageDelta =
     (aMessage == MOZ_WM_VSCROLL) ? wheelEvent.lineOrPageDeltaY :
                                    wheelEvent.lineOrPageDeltaX;
  
    delta = 1.0;
    lineOrPageDelta = 1;
  
    switch (LOWORD(aWParam)) {
      case SB_PAGEUP:
        delta = -1.0;
        lineOrPageDelta = -1;
      case SB_PAGEDOWN:
        wheelEvent.deltaMode = nsIDOMWheelEvent::DOM_DELTA_PAGE;
        break;
  
      case SB_LINEUP:
        delta = -1.0;
        lineOrPageDelta = -1;
      case SB_LINEDOWN:
        wheelEvent.deltaMode = nsIDOMWheelEvent::DOM_DELTA_LINE;
        break;
  
      default:
        return;
    }
    modKeyState.InitInputEvent(wheelEvent);
    // XXX Current mouse position may not be same as when the original message
    //     is received.  We need to know the actual mouse cursor position when
    //     the original message was received.
    InitEvent(aWindow, wheelEvent);
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::HandleScrollMessageAsMouseWheelMessage: aWindow=%p, "
       "aMessage=MOZ_WM_%sSCROLL, aWParam=0x%08X, aLParam=0x%08X, "
       "wheelEvent { refPoint: { x: %d, y: %d }, deltaX: %f, deltaY: %f, "
       "lineOrPageDeltaX: %d, lineOrPageDeltaY: %d, "
       "isShift: %s, isControl: %s, isAlt: %s, isMeta: %s }",
       aWindow, (aMessage == MOZ_WM_VSCROLL) ? "V" : "H", aWParam, aLParam,
       wheelEvent.refPoint.x, wheelEvent.refPoint.y,
       wheelEvent.deltaX, wheelEvent.deltaY,
       wheelEvent.lineOrPageDeltaX, wheelEvent.lineOrPageDeltaY,
       GetBoolName(wheelEvent.IsShift()),
       GetBoolName(wheelEvent.IsControl()),
       GetBoolName(wheelEvent.IsAlt()),
       GetBoolName(wheelEvent.IsMeta())));
  
    DispatchEvent(aWindow, wheelEvent);
  }
  
  /******************************************************************************
   *
   * EventInfo
   *
   ******************************************************************************/
  
  MouseScrollHandler::EventInfo::EventInfo(nsWindow* aWindow,
                                           UINT aMessage,
                                           WPARAM aWParam, LPARAM aLParam)
  {
    NS_ABORT_IF_FALSE(aMessage == WM_MOUSEWHEEL || aMessage == WM_MOUSEHWHEEL,
      "EventInfo must be initialized with WM_MOUSEWHEEL or WM_MOUSEHWHEEL");
  
    MouseScrollHandler::GetInstance()->mSystemSettings.Init();
  
    mIsVertical = (aMessage == WM_MOUSEWHEEL);
    mIsPage = MouseScrollHandler::sInstance->
                mSystemSettings.IsPageScroll(mIsVertical);
    mDelta = (short)HIWORD(aWParam);
    mWnd = aWindow->GetWindowHandle();
    mTimeStamp = TimeStamp::Now();
  }
  
  bool
  MouseScrollHandler::EventInfo::CanDispatchWheelEvent() const
  {
    if (!GetScrollAmount()) {
      // XXX I think that we should dispatch mouse wheel events even if the
      // operation will not scroll because the wheel operation really happened
      // and web application may want to handle the event for non-scroll action.
      return false;
    }
  
    return (mDelta != 0);
  }
  
  int32_t
  MouseScrollHandler::EventInfo::GetScrollAmount() const
  {
    if (mIsPage) {
      return 1;
    }
    return MouseScrollHandler::sInstance->
             mSystemSettings.GetScrollAmount(mIsVertical);
  }
  
  /******************************************************************************
   *
   * LastEventInfo
   *
   ******************************************************************************/
  
  bool
  MouseScrollHandler::LastEventInfo::CanContinueTransaction(
                                       const EventInfo& aNewEvent)
  {
    int32_t timeout = MouseScrollHandler::sInstance->
                        mUserPrefs.GetMouseScrollTransactionTimeout();
    return !mWnd ||
             (mWnd == aNewEvent.GetWindowHandle() &&
              IsPositive() == aNewEvent.IsPositive() &&
              mIsVertical == aNewEvent.IsVertical() &&
              mIsPage == aNewEvent.IsPage() &&
              (timeout < 0 ||
               TimeStamp::Now() - mTimeStamp <=
                 TimeDuration::FromMilliseconds(timeout)));
  }
  
  void
  MouseScrollHandler::LastEventInfo::ResetTransaction()
  {
    if (!mWnd) {
      return;
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::LastEventInfo::ResetTransaction()"));
  
    mWnd = nullptr;
    mAccumulatedDelta = 0;
  }
  
  void
  MouseScrollHandler::LastEventInfo::RecordEvent(const EventInfo& aEvent)
  {
    mWnd = aEvent.GetWindowHandle();
    mDelta = aEvent.GetNativeDelta();
    mIsVertical = aEvent.IsVertical();
    mIsPage = aEvent.IsPage();
    mTimeStamp = TimeStamp::Now();
  }
  
  /* static */
  int32_t
  MouseScrollHandler::LastEventInfo::RoundDelta(double aDelta)
  {
    return (aDelta >= 0) ? (int32_t)floor(aDelta) : (int32_t)ceil(aDelta);
  }
  
  bool
  MouseScrollHandler::LastEventInfo::InitWheelEvent(
                                       nsWindow* aWindow,
                                       WheelEvent& aWheelEvent,
                                       const ModifierKeyState& aModKeyState)
  {
    MOZ_ASSERT(aWheelEvent.message == NS_WHEEL_WHEEL);
  
    // XXX Why don't we use lParam value? We should use lParam value because
    //     our internal message is always posted by original message handler.
    //     So, GetMessagePos() may return different cursor position.
    InitEvent(aWindow, aWheelEvent);
  
    aModKeyState.InitInputEvent(aWheelEvent);
  
    // Our positive delta value means to bottom or right.
    // But positive native delta value means to top or right.
    // Use orienter for computing our delta value with native delta value.
    int32_t orienter = mIsVertical ? -1 : 1;
  
    aWheelEvent.deltaMode = mIsPage ? nsIDOMWheelEvent::DOM_DELTA_PAGE :
                                      nsIDOMWheelEvent::DOM_DELTA_LINE;
  
    double& delta = mIsVertical ? aWheelEvent.deltaY : aWheelEvent.deltaX;
    int32_t& lineOrPageDelta = mIsVertical ? aWheelEvent.lineOrPageDeltaY :
                                             aWheelEvent.lineOrPageDeltaX;
  
    double nativeDeltaPerUnit =
      mIsPage ? static_cast<double>(WHEEL_DELTA) :
                static_cast<double>(WHEEL_DELTA) / GetScrollAmount();
  
    delta = static_cast<double>(mDelta) * orienter / nativeDeltaPerUnit;
    mAccumulatedDelta += mDelta;
    lineOrPageDelta =
      mAccumulatedDelta * orienter / RoundDelta(nativeDeltaPerUnit);
    mAccumulatedDelta -=
      lineOrPageDelta * orienter * RoundDelta(nativeDeltaPerUnit);
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::LastEventInfo::InitWheelEvent: aWindow=%p, "
       "aWheelEvent { refPoint: { x: %d, y: %d }, deltaX: %f, deltaY: %f, "
       "lineOrPageDeltaX: %d, lineOrPageDeltaY: %d, "
       "isShift: %s, isControl: %s, isAlt: %s, isMeta: %s }, "
       "mAccumulatedDelta: %d",
       aWindow, aWheelEvent.refPoint.x, aWheelEvent.refPoint.y,
       aWheelEvent.deltaX, aWheelEvent.deltaY,
       aWheelEvent.lineOrPageDeltaX, aWheelEvent.lineOrPageDeltaY,
       GetBoolName(aWheelEvent.IsShift()),
       GetBoolName(aWheelEvent.IsControl()),
       GetBoolName(aWheelEvent.IsAlt()),
       GetBoolName(aWheelEvent.IsMeta()), mAccumulatedDelta));
  
    return (delta != 0);
  }
  
  /******************************************************************************
   *
   * SystemSettings
   *
   ******************************************************************************/
  
  void
  MouseScrollHandler::SystemSettings::Init()
  {
    if (mInitialized) {
      return;
    }
  
    mInitialized = true;
  
    MouseScrollHandler::UserPrefs& userPrefs =
      MouseScrollHandler::sInstance->mUserPrefs;
  
    mScrollLines = userPrefs.GetOverriddenVerticalScrollAmout();
    if (mScrollLines >= 0) {
      // overridden by the pref.
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::SystemSettings::Init(): mScrollLines is overridden by "
         "the pref: %d",
         mScrollLines));
    } else if (!::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
                                       &mScrollLines, 0)) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::SystemSettings::Init(): ::SystemParametersInfo("
           "SPI_GETWHEELSCROLLLINES) failed"));
      mScrollLines = 3;
    }
  
    if (mScrollLines > WHEEL_DELTA) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::SystemSettings::Init(): the result of "
           "::SystemParametersInfo(SPI_GETWHEELSCROLLLINES) is too large: %d",
         mScrollLines));
      // sScrollLines usually equals 3 or 0 (for no scrolling)
      // However, if sScrollLines > WHEEL_DELTA, we assume that
      // the mouse driver wants a page scroll.  The docs state that
      // sScrollLines should explicitly equal WHEEL_PAGESCROLL, but
      // since some mouse drivers use an arbitrary large number instead,
      // we have to handle that as well.
      mScrollLines = WHEEL_PAGESCROLL;
    }
  
    mScrollChars = userPrefs.GetOverriddenHorizontalScrollAmout();
    if (mScrollChars >= 0) {
      // overridden by the pref.
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::SystemSettings::Init(): mScrollChars is overridden by "
         "the pref: %d",
         mScrollChars));
    } else if (!::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0,
                                       &mScrollChars, 0)) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::SystemSettings::Init(): ::SystemParametersInfo("
           "SPI_GETWHEELSCROLLCHARS) failed, %s",
         WinUtils::GetWindowsVersion() >= WinUtils::VISTA_VERSION ?
           "this is unexpected on Vista or later" :
           "but on XP or earlier, this is not a problem"));
      mScrollChars = 1;
    }
  
    if (mScrollChars > WHEEL_DELTA) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::SystemSettings::Init(): the result of "
           "::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS) is too large: %d",
         mScrollChars));
      // See the comments for the case mScrollLines > WHEEL_DELTA.
      mScrollChars = WHEEL_PAGESCROLL;
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::SystemSettings::Init(): initialized, "
         "mScrollLines=%d, mScrollChars=%d",
       mScrollLines, mScrollChars));
  }
  
  void
  MouseScrollHandler::SystemSettings::MarkDirty()
  {
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScrollHandler::SystemSettings::MarkDirty(): "
         "Marking SystemSettings dirty"));
    mInitialized = false;
    // When system settings are changed, we should reset current transaction.
    MOZ_ASSERT(sInstance,
      "Must not be called at initializing MouseScrollHandler");
    MouseScrollHandler::sInstance->mLastEventInfo.ResetTransaction();
  }
  
  /******************************************************************************
   *
   * UserPrefs
   *
   ******************************************************************************/
  
  MouseScrollHandler::UserPrefs::UserPrefs() :
    mInitialized(false)
  {
    // We need to reset mouse wheel transaction when all of mousewheel related
    // prefs are changed.
    DebugOnly<nsresult> rv =
      Preferences::RegisterCallback(OnChange, "mousewheel.", this);
    MOZ_ASSERT(NS_SUCCEEDED(rv),
      "Failed to register callback for mousewheel.");
  }
  
  MouseScrollHandler::UserPrefs::~UserPrefs()
  {
    DebugOnly<nsresult> rv =
      Preferences::UnregisterCallback(OnChange, "mousewheel.", this);
    MOZ_ASSERT(NS_SUCCEEDED(rv),
      "Failed to unregister callback for mousewheel.");
  }
  
  void
  MouseScrollHandler::UserPrefs::Init()
  {
    if (mInitialized) {
      return;
    }
  
    mInitialized = true;
  
    mScrollMessageHandledAsWheelMessage =
      Preferences::GetBool("mousewheel.emulate_at_wm_scroll", false);
    mOverriddenVerticalScrollAmount =
      Preferences::GetInt("mousewheel.windows.vertical_amount_override", -1);
    mOverriddenHorizontalScrollAmount =
      Preferences::GetInt("mousewheel.windows.horizontal_amount_override", -1);
    mMouseScrollTransactionTimeout =
      Preferences::GetInt("mousewheel.windows.transaction.timeout",
                          DEFAULT_TIMEOUT_DURATION);
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::UserPrefs::Init(): initialized, "
         "mScrollMessageHandledAsWheelMessage=%s, "
         "mOverriddenVerticalScrollAmount=%d, "
         "mOverriddenHorizontalScrollAmount=%d, "
         "mMouseScrollTransactionTimeout=%d",
       GetBoolName(mScrollMessageHandledAsWheelMessage),
       mOverriddenVerticalScrollAmount, mOverriddenHorizontalScrollAmount,
       mMouseScrollTransactionTimeout));
  }
  
  void
  MouseScrollHandler::UserPrefs::MarkDirty()
  {
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScrollHandler::UserPrefs::MarkDirty(): Marking UserPrefs dirty"));
    mInitialized = false;
    // Some prefs might override system settings, so, we should mark them dirty.
    MouseScrollHandler::sInstance->mSystemSettings.MarkDirty();
    // When user prefs for mousewheel are changed, we should reset current
    // transaction.
    MOZ_ASSERT(sInstance,
      "Must not be called at initializing MouseScrollHandler");
    MouseScrollHandler::sInstance->mLastEventInfo.ResetTransaction();
  }
  
  /******************************************************************************
   *
   * Device
   *
   ******************************************************************************/
  
  /* static */
  bool
  MouseScrollHandler::Device::GetWorkaroundPref(const char* aPrefName,
                                                bool aValueIfAutomatic)
  {
    if (!aPrefName) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::GetWorkaroundPref(): Failed, aPrefName is NULL"));
      return aValueIfAutomatic;
    }
  
    int32_t lHackValue = 0;
    if (NS_FAILED(Preferences::GetInt(aPrefName, &lHackValue))) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::GetWorkaroundPref(): Preferences::GetInt() failed,"
         " aPrefName=\"%s\", aValueIfAutomatic=%s",
         aPrefName, GetBoolName(aValueIfAutomatic)));
      return aValueIfAutomatic;
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::Device::GetWorkaroundPref(): Succeeded, "
       "aPrefName=\"%s\", aValueIfAutomatic=%s, lHackValue=%d",
       aPrefName, GetBoolName(aValueIfAutomatic), lHackValue));
  
    switch (lHackValue) {
      case 0: // disabled
        return false;
      case 1: // enabled
        return true;
      default: // -1: autodetect
        return aValueIfAutomatic;
    }
  }
  
  /* static */
  void
  MouseScrollHandler::Device::Init()
  {
    sFakeScrollableWindowNeeded =
      GetWorkaroundPref("ui.trackpoint_hack.enabled",
                        (TrackPoint::IsDriverInstalled() ||
                         UltraNav::IsObsoleteDriverInstalled()));
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::Device::Init(): sFakeScrollableWindowNeeded=%s",
       GetBoolName(sFakeScrollableWindowNeeded)));
  
    Elantech::Init();
  }
  
  /******************************************************************************
   *
   * Device::Elantech
   *
   ******************************************************************************/
  
  /* static */
  void
  MouseScrollHandler::Device::Elantech::Init()
  {
    int32_t version = GetDriverMajorVersion();
    bool needsHack =
      Device::GetWorkaroundPref("ui.elantech_gesture_hacks.enabled",
                                version != 0);
    sUseSwipeHack = needsHack && version <= 7;
    sUsePinchHack = needsHack && version <= 8;
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::Device::Elantech::Init(): version=%d, sUseSwipeHack=%s, "
       "sUsePinchHack=%s",
       version, GetBoolName(sUseSwipeHack), GetBoolName(sUsePinchHack)));
  }
  
  /* static */
  int32_t
  MouseScrollHandler::Device::Elantech::GetDriverMajorVersion()
  {
    PRUnichar buf[40];
    // The driver version is found in one of these two registry keys.
    bool foundKey =
      WinUtils::GetRegistryKey(HKEY_CURRENT_USER,
                               L"Software\\Elantech\\MainOption",
                               L"DriverVersion",
                               buf, sizeof buf);
    if (!foundKey) {
      foundKey =
        WinUtils::GetRegistryKey(HKEY_CURRENT_USER,
                                 L"Software\\Elantech",
                                 L"DriverVersion",
                                 buf, sizeof buf);
    }
  
    if (!foundKey) {
      return 0;
    }
  
    // Assume that the major version number can be found just after a space
    // or at the start of the string.
    for (PRUnichar* p = buf; *p; p++) {
      if (*p >= L'0' && *p <= L'9' && (p == buf || *(p - 1) == L' ')) {
        return wcstol(p, NULL, 10);
      }
    }
  
    return 0;
  }
  
  /* static */
  bool
  MouseScrollHandler::Device::Elantech::IsHelperWindow(HWND aWnd)
  {
    // The helper window cannot be distinguished based on its window class, so we
    // need to check if it is owned by the helper process, ETDCtrl.exe.
  
    const PRUnichar* filenameSuffix = L"\\etdctrl.exe";
    const int filenameSuffixLength = 12;
  
    DWORD pid;
    ::GetWindowThreadProcessId(aWnd, &pid);
  
    HANDLE hProcess = ::OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
    if (!hProcess) {
      return false;
    }
  
    bool result = false;
    PRUnichar path[256] = {L'\0'};
    if (::GetProcessImageFileNameW(hProcess, path, ArrayLength(path))) {
      int pathLength = lstrlenW(path);
      if (pathLength >= filenameSuffixLength) {
        if (lstrcmpiW(path + pathLength - filenameSuffixLength,
                      filenameSuffix) == 0) {
          result = true;
        }
      }
    }
    ::CloseHandle(hProcess);
  
    return result;
  }
  
  /* static */
  bool
  MouseScrollHandler::Device::Elantech::HandleKeyMessage(nsWindow* aWindow,
                                                         UINT aMsg,
                                                         WPARAM aWParam)
  {
    // The Elantech touchpad driver understands three-finger swipe left and
    // right gestures, and translates them into Page Up and Page Down key
    // events for most applications.  For Firefox 3.6, it instead sends
    // Alt+Left and Alt+Right to trigger browser back/forward actions.  As
    // with the Thinkpad Driver hack in nsWindow::Create, the change in
    // HWND structure makes Firefox not trigger the driver's heuristics
    // any longer.
    //
    // The Elantech driver actually sends these messages for a three-finger
    // swipe right:
    //
    //   WM_KEYDOWN virtual_key = 0xCC or 0xFF (depending on driver version)
    //   WM_KEYDOWN virtual_key = VK_NEXT
    //   WM_KEYUP   virtual_key = VK_NEXT
    //   WM_KEYUP   virtual_key = 0xCC or 0xFF
    //
    // so we use the 0xCC or 0xFF key modifier to detect whether the Page Down
    // is due to the gesture rather than a regular Page Down keypress.  We then
    // pretend that we should dispatch "Go Forward" command.  Similarly
    // for VK_PRIOR and "Go Back" command.
    if (sUseSwipeHack &&
        (aWParam == VK_NEXT || aWParam == VK_PRIOR) &&
        (IS_VK_DOWN(0xFF) || IS_VK_DOWN(0xCC))) {
      if (aMsg == WM_KEYDOWN) {
        PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
          ("MouseScroll::Device::Elantech::HandleKeyMessage(): Dispatching "
           "%s command event",
           aWParam == VK_NEXT ? "Forward" : "Back"));
  
        nsCommandEvent commandEvent(true, nsGkAtoms::onAppCommand,
          (aWParam == VK_NEXT) ? nsGkAtoms::Forward : nsGkAtoms::Back, aWindow);
        InitEvent(aWindow, commandEvent);
        MouseScrollHandler::DispatchEvent(aWindow, commandEvent);
      }
  #ifdef PR_LOGGING
      else {
        PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
          ("MouseScroll::Device::Elantech::HandleKeyMessage(): Consumed"));
      }
  #endif
      return true; // consume the message (doesn't need to dispatch key events)
    }
  
    // Version 8 of the Elantech touchpad driver sends these messages for
    // zoom gestures:
    //
    //   WM_KEYDOWN    virtual_key = 0xCC        time = 10
    //   WM_KEYDOWN    virtual_key = VK_CONTROL  time = 10
    //   WM_MOUSEWHEEL                           time = ::GetTickCount()
    //   WM_KEYUP      virtual_key = VK_CONTROL  time = 10
    //   WM_KEYUP      virtual_key = 0xCC        time = 10
    //
    // The result of this is that we process all of the WM_KEYDOWN/WM_KEYUP
    // messages first because their timestamps make them appear to have
    // been sent before the WM_MOUSEWHEEL message.  To work around this,
    // we store the current time when we process the WM_KEYUP message and
    // assume that any WM_MOUSEWHEEL message with a timestamp before that
    // time is one that should be processed as if the Control key was down.
    if (sUsePinchHack && aMsg == WM_KEYUP &&
        aWParam == VK_CONTROL && ::GetMessageTime() == 10) {
      // We look only at the bottom 31 bits of the system tick count since
      // GetMessageTime returns a LONG, which is signed, so we want values
      // that are more easily comparable.
      sZoomUntil = ::GetTickCount() & 0x7FFFFFFF;
  
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::Elantech::HandleKeyMessage(): sZoomUntil=%d",
         sZoomUntil));
    }
  
    return false;
  }
  
  /* static */
  void
  MouseScrollHandler::Device::Elantech::UpdateZoomUntil()
  {
    if (!sZoomUntil) {
      return;
    }
  
    // For the Elantech Touchpad Zoom Gesture Hack, we should check that the
    // system time (32-bit milliseconds) hasn't wrapped around.  Otherwise we
    // might get into the situation where wheel events for the next 50 days of
    // system uptime are assumed to be Ctrl+Wheel events.  (It is unlikely that
    // we would get into that state, because the system would already need to be
    // up for 50 days and the Control key message would need to be processed just
    // before the system time overflow and the wheel message just after.)
    //
    // We also take the chance to reset sZoomUntil if we simply have passed that
    // time.
    LONG msgTime = ::GetMessageTime();
    if ((sZoomUntil >= 0x3fffffffu && DWORD(msgTime) < 0x40000000u) ||
        (sZoomUntil < DWORD(msgTime))) {
      sZoomUntil = 0;
  
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::Elantech::UpdateZoomUntil(): "
         "sZoomUntil was reset"));
    }
  }
  
  /* static */
  bool
  MouseScrollHandler::Device::Elantech::IsZooming()
  {
    // Assume the Control key is down if the Elantech touchpad has sent the
    // mis-ordered WM_KEYDOWN/WM_MOUSEWHEEL messages.  (See the comment in
    // OnKeyUp.)
    return (sZoomUntil && static_cast<DWORD>(::GetMessageTime()) < sZoomUntil);
  }
  
  /******************************************************************************
   *
   * Device::TrackPoint
   *
   ******************************************************************************/
  
  /* static */
  bool
  MouseScrollHandler::Device::TrackPoint::IsDriverInstalled()
  {
    if (WinUtils::HasRegistryKey(HKEY_CURRENT_USER,
                                 L"Software\\Lenovo\\TrackPoint")) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::TrackPoint::IsDriverInstalled(): "
         "Lenovo's TrackPoint driver is found"));
      return true;
    }
  
    if (WinUtils::HasRegistryKey(HKEY_CURRENT_USER,
                                 L"Software\\Alps\\Apoint\\TrackPoint")) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::TrackPoint::IsDriverInstalled(): "
         "Alps's TrackPoint driver is found"));
    }
  
    return false;
  }
  
  /******************************************************************************
   *
   * Device::UltraNav
   *
   ******************************************************************************/
  
  /* static */
  bool
  MouseScrollHandler::Device::UltraNav::IsObsoleteDriverInstalled()
  {
    if (WinUtils::HasRegistryKey(HKEY_CURRENT_USER,
                                 L"Software\\Lenovo\\UltraNav")) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::UltraNav::IsObsoleteDriverInstalled(): "
         "Lenovo's UltraNav driver is found"));
      return true;
    }
  
    bool installed = false;
    if (WinUtils::HasRegistryKey(HKEY_CURRENT_USER,
          L"Software\\Synaptics\\SynTPEnh\\UltraNavUSB")) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::UltraNav::IsObsoleteDriverInstalled(): "
         "Synaptics's UltraNav (USB) driver is found"));
      installed = true;
    } else if (WinUtils::HasRegistryKey(HKEY_CURRENT_USER,
                 L"Software\\Synaptics\\SynTPEnh\\UltraNavPS2")) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::UltraNav::IsObsoleteDriverInstalled(): "
         "Synaptics's UltraNav (PS/2) driver is found"));
      installed = true;
    }
  
    if (!installed) {
      return false;
    }
  
    PRUnichar buf[40];
    bool foundKey =
      WinUtils::GetRegistryKey(HKEY_LOCAL_MACHINE,
                               L"Software\\Synaptics\\SynTP\\Install",
                               L"DriverVersion",
                               buf, sizeof buf);
    if (!foundKey) {
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::UltraNav::IsObsoleteDriverInstalled(): "
         "Failed to get UltraNav driver version"));
      return false;
    }
  
    int majorVersion = wcstol(buf, NULL, 10);
    int minorVersion = 0;
    PRUnichar* p = wcschr(buf, L'.');
    if (p) {
      minorVersion = wcstol(p + 1, NULL, 10);
    }
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScroll::Device::UltraNav::IsObsoleteDriverInstalled(): "
       "found driver version = %d.%d",
       majorVersion, minorVersion));
    return majorVersion < 15 || (majorVersion == 15 && minorVersion == 0);
  }
  
  /******************************************************************************
   *
   * Device::SetPoint
   *
   ******************************************************************************/
  
  /* static */
  bool
  MouseScrollHandler::Device::SetPoint::IsGetMessagePosResponseValid(
                                          UINT aMessage,
                                          WPARAM aWParam,
                                          LPARAM aLParam)
  {
    if (aMessage != WM_MOUSEHWHEEL) {
      return false;
    }
  
    POINTS pts = MouseScrollHandler::GetCurrentMessagePos();
    LPARAM messagePos = MAKELPARAM(pts.x, pts.y);
  
    // XXX We should check whether SetPoint is installed or not by registry.
  
    // SetPoint, Logitech (Logicool) mouse driver, (confirmed with 4.82.11 and
    // MX-1100) always sets 0 to the lParam of WM_MOUSEHWHEEL.  The driver SENDs
    // one message at first time, this time, ::GetMessagePos() works fine.
    // Then, we will return 0 (0 means we process it) to the message. Then, the
    // driver will POST the same messages continuously during the wheel tilted.
    // But ::GetMessagePos() API always returns (0, 0) for them, even if the
    // actual mouse cursor isn't 0,0.  Therefore, we cannot trust the result of
    // ::GetMessagePos API if the sender is SetPoint.
    if (!sMightBeUsing && !aLParam && aLParam != messagePos &&
        ::InSendMessage()) {
      sMightBeUsing = true;
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::SetPoint::IsGetMessagePosResponseValid(): "
         "Might using SetPoint"));
    } else if (sMightBeUsing && aLParam != 0 && ::InSendMessage()) {
      // The user has changed the mouse from Logitech's to another one (e.g.,
      // the user has changed to the touchpad of the notebook.
      sMightBeUsing = false;
      PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
        ("MouseScroll::Device::SetPoint::IsGetMessagePosResponseValid(): "
         "Might stop using SetPoint"));
    }
    return (sMightBeUsing && !aLParam && !messagePos);
  }
  
  /******************************************************************************
   *
   * SynthesizingEvent
   *
   ******************************************************************************/
  
  /* static */
  bool
  MouseScrollHandler::SynthesizingEvent::IsSynthesizing()
  {
    return MouseScrollHandler::sInstance &&
      MouseScrollHandler::sInstance->mSynthesizingEvent &&
      MouseScrollHandler::sInstance->mSynthesizingEvent->mStatus !=
        NOT_SYNTHESIZING;
  }
  
  nsresult
  MouseScrollHandler::SynthesizingEvent::Synthesize(const POINTS& aCursorPoint,
                                                    HWND aWnd,
                                                    UINT aMessage,
                                                    WPARAM aWParam,
                                                    LPARAM aLParam,
                                                    const BYTE (&aKeyStates)[256])
  {
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScrollHandler::SynthesizingEvent::Synthesize(): aCursorPoint: { "
       "x: %d, y: %d }, aWnd=0x%X, aMessage=0x%04X, aWParam=0x%08X, "
       "aLParam=0x%08X, IsSynthesized()=%s, mStatus=%s",
       aCursorPoint.x, aCursorPoint.y, aWnd, aMessage, aWParam, aLParam,
       GetBoolName(IsSynthesizing()), GetStatusName()));
  
    if (IsSynthesizing()) {
      return NS_ERROR_NOT_AVAILABLE;
    }
  
    ::GetKeyboardState(mOriginalKeyState);
  
    // Note that we cannot use ::SetCursorPos() because it works asynchronously.
    // We should SEND the message for reducing the possibility of receiving
    // unexpected message which were not sent from here.
    mCursorPoint = aCursorPoint;
  
    mWnd = aWnd;
    mMessage = aMessage;
    mWParam = aWParam;
    mLParam = aLParam;
  
    memcpy(mKeyState, aKeyStates, sizeof(mKeyState));
    ::SetKeyboardState(mKeyState);
  
    mStatus = SENDING_MESSAGE;
  
    // Don't assume that aWnd is always managed by nsWindow.  It might be
    // a plugin window.
    ::SendMessage(aWnd, aMessage, aWParam, aLParam);
  
    return NS_OK;
  }
  
  void
  MouseScrollHandler::SynthesizingEvent::NativeMessageReceived(nsWindow* aWindow,
                                                               UINT aMessage,
                                                               WPARAM aWParam,
                                                               LPARAM aLParam)
  {
    if (mStatus == SENDING_MESSAGE && mMessage == aMessage &&
        mWParam == aWParam && mLParam == aLParam) {
      mStatus = NATIVE_MESSAGE_RECEIVED;
      if (aWindow && aWindow->GetWindowHandle() == mWnd) {
        return;
      }
      // If the target window is not ours and received window is our plugin
      // window, it comes from child window of the plugin.
      if (aWindow && aWindow->GetWindowType() == eWindowType_plugin &&
          !WinUtils::GetNSWindowPtr(mWnd)) {
        return;
      }
      // Otherwise, the message may not be sent by us.
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScrollHandler::SynthesizingEvent::NativeMessageReceived(): "
       "aWindow=%p, aWindow->GetWindowHandle()=0x%X, mWnd=0x%X, "
       "aMessage=0x%04X, aWParam=0x%08X, aLParam=0x%08X, mStatus=%s",
       aWindow, aWindow ? aWindow->GetWindowHandle() : 0, mWnd,
       aMessage, aWParam, aLParam, GetStatusName()));
  
    // We failed to receive our sent message, we failed to do the job.
    Finish();
  
    return;
  }
  
  void
  MouseScrollHandler::SynthesizingEvent::NotifyNativeMessageHandlingFinished()
  {
    if (!IsSynthesizing()) {
      return;
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScrollHandler::SynthesizingEvent::"
       "NotifyNativeMessageHandlingFinished(): IsWaitingInternalMessage=%s",
       GetBoolName(MouseScrollHandler::IsWaitingInternalMessage())));
  
    if (MouseScrollHandler::IsWaitingInternalMessage()) {
      mStatus = INTERNAL_MESSAGE_POSTED;
      return;
    }
  
    // If the native message handler didn't post our internal message,
    // we our job is finished.
    // TODO: When we post the message to plugin window, there is remaning job.
    Finish();
  }
  
  void
  MouseScrollHandler::SynthesizingEvent::NotifyInternalMessageHandlingFinished()
  {
    if (!IsSynthesizing()) {
      return;
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScrollHandler::SynthesizingEvent::"
       "NotifyInternalMessageHandlingFinished()"));
  
    Finish();
  }
  
  void
  MouseScrollHandler::SynthesizingEvent::Finish()
  {
    if (!IsSynthesizing()) {
      return;
    }
  
    PR_LOG(gMouseScrollLog, PR_LOG_ALWAYS,
      ("MouseScrollHandler::SynthesizingEvent::Finish()"));
  
    // Restore the original key state.
    ::SetKeyboardState(mOriginalKeyState);
  
    mStatus = NOT_SYNTHESIZING;
  }
  
  } // namespace widget
  } // namespace mozilla
  