mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-11 02:56:06 +00:00
612 lines
18 KiB
C++
612 lines
18 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef mozilla_widget_WinMouseScrollHandler_h__
|
|
#define mozilla_widget_WinMouseScrollHandler_h__
|
|
|
|
#include "nscore.h"
|
|
#include "nsDebug.h"
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/EventForwards.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "Units.h"
|
|
#include <windows.h>
|
|
#include "nsPoint.h"
|
|
|
|
class nsWindowBase;
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
class ModifierKeyState;
|
|
|
|
struct MSGResult;
|
|
|
|
class MouseScrollHandler {
|
|
public:
|
|
static MouseScrollHandler* GetInstance();
|
|
|
|
static void Initialize();
|
|
static void Shutdown();
|
|
|
|
static bool NeedsMessage(UINT aMsg);
|
|
static bool ProcessMessage(nsWindowBase* aWidget,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam,
|
|
MSGResult& aResult);
|
|
|
|
/**
|
|
* See nsIWidget::SynthesizeNativeMouseScrollEvent() for the detail about
|
|
* this method.
|
|
*/
|
|
static nsresult SynthesizeNativeMouseScrollEvent(nsWindowBase* aWidget,
|
|
const LayoutDeviceIntPoint& aPoint,
|
|
uint32_t aNativeMessage,
|
|
int32_t aDelta,
|
|
uint32_t aModifierFlags,
|
|
uint32_t aAdditionalFlags);
|
|
|
|
/**
|
|
* IsWaitingInternalMessage() returns true if MouseScrollHandler posted
|
|
* an internal message for a native mouse wheel message and has not
|
|
* received it. Otherwise, false.
|
|
*/
|
|
static bool IsWaitingInternalMessage()
|
|
{
|
|
return sInstance && sInstance->mIsWaitingInternalMessage;
|
|
}
|
|
|
|
private:
|
|
MouseScrollHandler();
|
|
~MouseScrollHandler();
|
|
|
|
bool mIsWaitingInternalMessage;
|
|
|
|
static MouseScrollHandler* sInstance;
|
|
|
|
/**
|
|
* InitEvent() initializes the aEvent. If aPoint is null, the result of
|
|
* GetCurrentMessagePos() will be used.
|
|
*/
|
|
static void InitEvent(nsWindowBase* aWidget,
|
|
WidgetGUIEvent& aEvent,
|
|
LayoutDeviceIntPoint* aPoint = nullptr);
|
|
|
|
/**
|
|
* GetModifierKeyState() returns current modifier key state.
|
|
* Note that some devices need some hack for the modifier key state.
|
|
* This method does it automatically.
|
|
*
|
|
* @param aMessage Handling message.
|
|
*/
|
|
static ModifierKeyState GetModifierKeyState(UINT aMessage);
|
|
|
|
/**
|
|
* MozGetMessagePos() returns the mouse cursor position when GetMessage()
|
|
* was called last time. However, if we're sending a native message,
|
|
* this returns the specified cursor position by
|
|
* SynthesizeNativeMouseScrollEvent().
|
|
*/
|
|
static POINTS GetCurrentMessagePos();
|
|
|
|
/**
|
|
* ProcessNativeMouseWheelMessage() processes WM_MOUSEWHEEL and
|
|
* WM_MOUSEHWHEEL. Additionally, processes WM_VSCROLL and WM_HSCROLL if they
|
|
* should be processed as mouse wheel message.
|
|
* This method posts MOZ_WM_MOUSEVWHEEL, MOZ_WM_MOUSEHWHEEL,
|
|
* MOZ_WM_VSCROLL or MOZ_WM_HSCROLL if we need to dispatch mouse scroll
|
|
* events. That avoids deadlock with plugin process.
|
|
*
|
|
* @param aWidget A window which receives the message.
|
|
* @param aMessage WM_MOUSEWHEEL, WM_MOUSEHWHEEL, WM_VSCROLL or
|
|
* WM_HSCROLL.
|
|
* @param aWParam The wParam value of the message.
|
|
* @param aLParam The lParam value of the message.
|
|
*/
|
|
void ProcessNativeMouseWheelMessage(nsWindowBase* aWidget,
|
|
UINT aMessage,
|
|
WPARAM aWParam,
|
|
LPARAM aLParam);
|
|
|
|
/**
|
|
* ProcessNativeScrollMessage() processes WM_VSCROLL and WM_HSCROLL.
|
|
* This method just call ProcessMouseWheelMessage() if the message should be
|
|
* processed as mouse wheel message. Otherwise, dispatches a content
|
|
* command event.
|
|
*
|
|
* @param aWidget A window which receives the message.
|
|
* @param aMessage WM_VSCROLL or WM_HSCROLL.
|
|
* @param aWParam The wParam value of the message.
|
|
* @param aLParam The lParam value of the message.
|
|
* @return TRUE if the message is processed. Otherwise, FALSE.
|
|
*/
|
|
bool ProcessNativeScrollMessage(nsWindowBase* aWidget,
|
|
UINT aMessage,
|
|
WPARAM aWParam,
|
|
LPARAM aLParam);
|
|
|
|
/**
|
|
* HandleMouseWheelMessage() processes MOZ_WM_MOUSEVWHEEL and
|
|
* MOZ_WM_MOUSEHWHEEL which are posted when one of our windows received
|
|
* WM_MOUSEWHEEL or WM_MOUSEHWHEEL for avoiding deadlock with OOPP.
|
|
*
|
|
* @param aWidget A window which receives the wheel message.
|
|
* @param aMessage MOZ_WM_MOUSEWHEEL or MOZ_WM_MOUSEHWHEEL.
|
|
* @param aWParam The wParam value of the original message.
|
|
* @param aLParam The lParam value of the original message.
|
|
*/
|
|
void HandleMouseWheelMessage(nsWindowBase* aWidget,
|
|
UINT aMessage,
|
|
WPARAM aWParam,
|
|
LPARAM aLParam);
|
|
|
|
/**
|
|
* HandleScrollMessageAsMouseWheelMessage() processes the MOZ_WM_VSCROLL and
|
|
* MOZ_WM_HSCROLL which are posted when one of mouse windows received
|
|
* WM_VSCROLL or WM_HSCROLL and user wants them to emulate mouse wheel
|
|
* message's behavior.
|
|
*
|
|
* @param aWidget A window which receives the scroll message.
|
|
* @param aMessage MOZ_WM_VSCROLL or MOZ_WM_HSCROLL.
|
|
* @param aWParam The wParam value of the original message.
|
|
* @param aLParam The lParam value of the original message.
|
|
*/
|
|
void HandleScrollMessageAsMouseWheelMessage(nsWindowBase* aWidget,
|
|
UINT aMessage,
|
|
WPARAM aWParam,
|
|
LPARAM aLParam);
|
|
|
|
/**
|
|
* ComputeMessagePos() computes the cursor position when the message was
|
|
* added to the queue.
|
|
*
|
|
* @param aMessage Handling message.
|
|
* @param aWParam Handling message's wParam.
|
|
* @param aLParam Handling message's lParam.
|
|
* @return Mouse cursor position when the message is added to
|
|
* the queue or current cursor position if the result of
|
|
* ::GetMessagePos() is broken.
|
|
*/
|
|
POINT ComputeMessagePos(UINT aMessage,
|
|
WPARAM aWParam,
|
|
LPARAM aLParam);
|
|
|
|
class EventInfo {
|
|
public:
|
|
/**
|
|
* @param aWidget An nsWindow which is handling the event.
|
|
* @param aMessage Must be WM_MOUSEWHEEL or WM_MOUSEHWHEEL.
|
|
*/
|
|
EventInfo(nsWindowBase* aWidget, UINT aMessage, WPARAM aWParam, LPARAM aLParam);
|
|
|
|
bool CanDispatchWheelEvent() const;
|
|
|
|
int32_t GetNativeDelta() const { return mDelta; }
|
|
HWND GetWindowHandle() const { return mWnd; }
|
|
const TimeStamp& GetTimeStamp() const { return mTimeStamp; }
|
|
bool IsVertical() const { return mIsVertical; }
|
|
bool IsPositive() const { return (mDelta > 0); }
|
|
bool IsPage() const { return mIsPage; }
|
|
|
|
/**
|
|
* @return Number of lines or pages scrolled per WHEEL_DELTA.
|
|
*/
|
|
int32_t GetScrollAmount() const;
|
|
|
|
protected:
|
|
EventInfo() :
|
|
mIsVertical(false), mIsPage(false), mDelta(0), mWnd(nullptr)
|
|
{
|
|
}
|
|
|
|
// TRUE if event is for vertical scroll. Otherwise, FALSE.
|
|
bool mIsVertical;
|
|
// TRUE if event scrolls per page, otherwise, FALSE.
|
|
bool mIsPage;
|
|
// The native delta value.
|
|
int32_t mDelta;
|
|
// The window handle which is handling the event.
|
|
HWND mWnd;
|
|
// Timestamp of the event.
|
|
TimeStamp mTimeStamp;
|
|
};
|
|
|
|
class LastEventInfo : public EventInfo {
|
|
public:
|
|
LastEventInfo() :
|
|
EventInfo(), mAccumulatedDelta(0)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* CanContinueTransaction() checks whether the new event can continue the
|
|
* last transaction or not. Note that if there is no transaction, this
|
|
* returns true.
|
|
*/
|
|
bool CanContinueTransaction(const EventInfo& aNewEvent);
|
|
|
|
/**
|
|
* ResetTransaction() resets the transaction, i.e., the instance forgets
|
|
* the last event information.
|
|
*/
|
|
void ResetTransaction();
|
|
|
|
/**
|
|
* RecordEvent() saves the information of new event.
|
|
*/
|
|
void RecordEvent(const EventInfo& aEvent);
|
|
|
|
/**
|
|
* InitWheelEvent() initializes NS_WHEEL_WHEEL event and
|
|
* recomputes the remaning detla for the event.
|
|
* This must be called only once during handling a message and after
|
|
* RecordEvent() is called.
|
|
*
|
|
* @param aWidget A window which will dispatch the event.
|
|
* @param aWheelEvent An NS_WHEEL_WHEEL event, this will be
|
|
* initialized.
|
|
* @param aModKeyState Current modifier key state.
|
|
* @return TRUE if the event is ready to dispatch.
|
|
* Otherwise, FALSE.
|
|
*/
|
|
bool InitWheelEvent(nsWindowBase* aWidget,
|
|
WidgetWheelEvent& aWheelEvent,
|
|
const ModifierKeyState& aModKeyState);
|
|
|
|
private:
|
|
static int32_t RoundDelta(double aDelta);
|
|
|
|
int32_t mAccumulatedDelta;
|
|
};
|
|
|
|
LastEventInfo mLastEventInfo;
|
|
|
|
class SystemSettings {
|
|
public:
|
|
SystemSettings() : mInitialized(false) {}
|
|
|
|
void Init();
|
|
void MarkDirty();
|
|
void NotifyUserPrefsMayOverrideSystemSettings();
|
|
|
|
// On some environments, SystemParametersInfo() may be hooked by touchpad
|
|
// utility or something. In such case, when user changes active pointing
|
|
// device to another one, the result of SystemParametersInfo() may be
|
|
// changed without WM_SETTINGCHANGE message. For avoiding this trouble,
|
|
// we need to modify cache of system settings at every wheel message
|
|
// handling if we meet known device whose utility may hook the API.
|
|
void TrustedScrollSettingsDriver(bool aIsVertical);
|
|
|
|
int32_t GetScrollAmount(bool aForVertical) const
|
|
{
|
|
MOZ_ASSERT(mInitialized, "SystemSettings must be initialized");
|
|
return aForVertical ? mScrollLines : mScrollChars;
|
|
}
|
|
|
|
bool IsPageScroll(bool aForVertical) const
|
|
{
|
|
MOZ_ASSERT(mInitialized, "SystemSettings must be initialized");
|
|
return aForVertical ? (uint32_t(mScrollLines) == WHEEL_PAGESCROLL) :
|
|
(uint32_t(mScrollChars) == WHEEL_PAGESCROLL);
|
|
}
|
|
|
|
private:
|
|
bool mInitialized;
|
|
// The result of SystemParametersInfo() may not be reliable since it may
|
|
// be hooked. So, if the values are initialized with prefs, we can trust
|
|
// the value. Following mIsReliableScroll* are set true when mScroll* are
|
|
// initialized with prefs.
|
|
bool mIsReliableScrollLines;
|
|
bool mIsReliableScrollChars;
|
|
|
|
int32_t mScrollLines;
|
|
int32_t mScrollChars;
|
|
|
|
// Returns true if cached value is changed.
|
|
bool InitScrollLines();
|
|
bool InitScrollChars();
|
|
|
|
void RefreshCache(bool aForVertical);
|
|
};
|
|
|
|
SystemSettings mSystemSettings;
|
|
|
|
class UserPrefs {
|
|
public:
|
|
UserPrefs();
|
|
~UserPrefs();
|
|
|
|
void MarkDirty();
|
|
|
|
bool IsScrollMessageHandledAsWheelMessage()
|
|
{
|
|
Init();
|
|
return mScrollMessageHandledAsWheelMessage;
|
|
}
|
|
|
|
bool IsSystemSettingCacheEnabled()
|
|
{
|
|
Init();
|
|
return mEnableSystemSettingCache;
|
|
}
|
|
|
|
bool IsSystemSettingCacheForciblyEnabled()
|
|
{
|
|
Init();
|
|
return mForceEnableSystemSettingCache;
|
|
}
|
|
|
|
int32_t GetOverriddenVerticalScrollAmout()
|
|
{
|
|
Init();
|
|
return mOverriddenVerticalScrollAmount;
|
|
}
|
|
|
|
int32_t GetOverriddenHorizontalScrollAmout()
|
|
{
|
|
Init();
|
|
return mOverriddenHorizontalScrollAmount;
|
|
}
|
|
|
|
int32_t GetMouseScrollTransactionTimeout()
|
|
{
|
|
Init();
|
|
return mMouseScrollTransactionTimeout;
|
|
}
|
|
|
|
private:
|
|
void Init();
|
|
|
|
static void OnChange(const char* aPrefName, void* aClosure)
|
|
{
|
|
static_cast<UserPrefs*>(aClosure)->MarkDirty();
|
|
}
|
|
|
|
bool mInitialized;
|
|
bool mScrollMessageHandledAsWheelMessage;
|
|
bool mEnableSystemSettingCache;
|
|
bool mForceEnableSystemSettingCache;
|
|
int32_t mOverriddenVerticalScrollAmount;
|
|
int32_t mOverriddenHorizontalScrollAmount;
|
|
int32_t mMouseScrollTransactionTimeout;
|
|
};
|
|
|
|
UserPrefs mUserPrefs;
|
|
|
|
class SynthesizingEvent {
|
|
public:
|
|
SynthesizingEvent() :
|
|
mWnd(nullptr), mMessage(0), mWParam(0), mLParam(0),
|
|
mStatus(NOT_SYNTHESIZING)
|
|
{
|
|
}
|
|
|
|
~SynthesizingEvent() {}
|
|
|
|
static bool IsSynthesizing();
|
|
|
|
nsresult Synthesize(const POINTS& aCursorPoint, HWND aWnd,
|
|
UINT aMessage, WPARAM aWParam, LPARAM aLParam,
|
|
const BYTE (&aKeyStates)[256]);
|
|
|
|
void NativeMessageReceived(nsWindowBase* aWidget, UINT aMessage,
|
|
WPARAM aWParam, LPARAM aLParam);
|
|
|
|
void NotifyNativeMessageHandlingFinished();
|
|
void NotifyInternalMessageHandlingFinished();
|
|
|
|
const POINTS& GetCursorPoint() const { return mCursorPoint; }
|
|
|
|
private:
|
|
POINTS mCursorPoint;
|
|
HWND mWnd;
|
|
UINT mMessage;
|
|
WPARAM mWParam;
|
|
LPARAM mLParam;
|
|
BYTE mKeyState[256];
|
|
BYTE mOriginalKeyState[256];
|
|
|
|
enum Status {
|
|
NOT_SYNTHESIZING,
|
|
SENDING_MESSAGE,
|
|
NATIVE_MESSAGE_RECEIVED,
|
|
INTERNAL_MESSAGE_POSTED,
|
|
};
|
|
Status mStatus;
|
|
|
|
const char* GetStatusName()
|
|
{
|
|
switch (mStatus) {
|
|
case NOT_SYNTHESIZING:
|
|
return "NOT_SYNTHESIZING";
|
|
case SENDING_MESSAGE:
|
|
return "SENDING_MESSAGE";
|
|
case NATIVE_MESSAGE_RECEIVED:
|
|
return "NATIVE_MESSAGE_RECEIVED";
|
|
case INTERNAL_MESSAGE_POSTED:
|
|
return "INTERNAL_MESSAGE_POSTED";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
void Finish();
|
|
}; // SynthesizingEvent
|
|
|
|
SynthesizingEvent* mSynthesizingEvent;
|
|
|
|
public:
|
|
|
|
class Device {
|
|
public:
|
|
// SynTP is a touchpad driver of Synaptics.
|
|
class SynTP
|
|
{
|
|
public:
|
|
static bool IsDriverInstalled()
|
|
{
|
|
return sMajorVersion != 0;
|
|
}
|
|
/**
|
|
* GetDriverMajorVersion() returns the installed driver's major version.
|
|
* If SynTP driver isn't installed, this returns 0.
|
|
*/
|
|
static int32_t GetDriverMajorVersion()
|
|
{
|
|
return sMajorVersion;
|
|
}
|
|
/**
|
|
* GetDriverMinorVersion() returns the installed driver's minor version.
|
|
* If SynTP driver isn't installed, this returns -1.
|
|
*/
|
|
static int32_t GetDriverMinorVersion()
|
|
{
|
|
return sMinorVersion;
|
|
}
|
|
|
|
static void Init();
|
|
|
|
private:
|
|
static bool sInitialized;
|
|
static int32_t sMajorVersion;
|
|
static int32_t sMinorVersion;
|
|
};
|
|
|
|
class Elantech {
|
|
public:
|
|
/**
|
|
* GetDriverMajorVersion() returns the installed driver's major version.
|
|
* If Elantech's driver was installed, returns 0.
|
|
*/
|
|
static int32_t GetDriverMajorVersion();
|
|
|
|
/**
|
|
* IsHelperWindow() checks whether aWnd is a helper window of Elantech's
|
|
* touchpad. Returns TRUE if so. Otherwise, FALSE.
|
|
*/
|
|
static bool IsHelperWindow(HWND aWnd);
|
|
|
|
/**
|
|
* Key message handler for Elantech's hack. Returns TRUE if the message
|
|
* is consumed by this handler. Otherwise, FALSE.
|
|
*/
|
|
static bool HandleKeyMessage(nsWindowBase* aWidget,
|
|
UINT aMsg,
|
|
WPARAM aWParam);
|
|
|
|
static void UpdateZoomUntil();
|
|
static bool IsZooming();
|
|
|
|
static void Init();
|
|
|
|
static bool IsPinchHackNeeded() { return sUsePinchHack; }
|
|
|
|
|
|
private:
|
|
// Whether to enable the Elantech swipe gesture hack.
|
|
static bool sUseSwipeHack;
|
|
// Whether to enable the Elantech pinch-to-zoom gesture hack.
|
|
static bool sUsePinchHack;
|
|
static DWORD sZoomUntil;
|
|
}; // class Elantech
|
|
|
|
// Apoint is a touchpad driver of Alps.
|
|
class Apoint
|
|
{
|
|
public:
|
|
static bool IsDriverInstalled()
|
|
{
|
|
return sMajorVersion != 0;
|
|
}
|
|
/**
|
|
* GetDriverMajorVersion() returns the installed driver's major version.
|
|
* If Apoint driver isn't installed, this returns 0.
|
|
*/
|
|
static int32_t GetDriverMajorVersion()
|
|
{
|
|
return sMajorVersion;
|
|
}
|
|
/**
|
|
* GetDriverMinorVersion() returns the installed driver's minor version.
|
|
* If Apoint driver isn't installed, this returns -1.
|
|
*/
|
|
static int32_t GetDriverMinorVersion()
|
|
{
|
|
return sMinorVersion;
|
|
}
|
|
|
|
static void Init();
|
|
|
|
private:
|
|
static bool sInitialized;
|
|
static int32_t sMajorVersion;
|
|
static int32_t sMinorVersion;
|
|
};
|
|
|
|
class TrackPoint {
|
|
public:
|
|
/**
|
|
* IsDriverInstalled() returns TRUE if TrackPoint's driver is installed.
|
|
* Otherwise, returns FALSE.
|
|
*/
|
|
static bool IsDriverInstalled();
|
|
}; // class TrackPoint
|
|
|
|
class UltraNav {
|
|
public:
|
|
/**
|
|
* IsObsoleteDriverInstalled() checks whether obsoleted UltraNav
|
|
* is installed on the environment.
|
|
* Returns TRUE if it was installed. Otherwise, FALSE.
|
|
*/
|
|
static bool IsObsoleteDriverInstalled();
|
|
}; // class UltraNav
|
|
|
|
class SetPoint {
|
|
public:
|
|
/**
|
|
* SetPoint, Logitech's mouse driver, may report wrong cursor position
|
|
* for WM_MOUSEHWHEEL message. See comment in the implementation for
|
|
* the detail.
|
|
*/
|
|
static bool IsGetMessagePosResponseValid(UINT aMessage,
|
|
WPARAM aWParam,
|
|
LPARAM aLParam);
|
|
private:
|
|
static bool sMightBeUsing;
|
|
};
|
|
|
|
static void Init();
|
|
|
|
static bool IsFakeScrollableWindowNeeded()
|
|
{
|
|
return sFakeScrollableWindowNeeded;
|
|
}
|
|
|
|
private:
|
|
/**
|
|
* Gets the bool value of aPrefName used to enable or disable an input
|
|
* workaround (like the Trackpoint hack). The pref can take values 0 (for
|
|
* disabled), 1 (for enabled) or -1 (to automatically detect whether to
|
|
* enable the workaround).
|
|
*
|
|
* @param aPrefName The name of the pref.
|
|
* @param aValueIfAutomatic Whether the given input workaround should be
|
|
* enabled by default.
|
|
*/
|
|
static bool GetWorkaroundPref(const char* aPrefName,
|
|
bool aValueIfAutomatic);
|
|
|
|
static bool sFakeScrollableWindowNeeded;
|
|
}; // class Device
|
|
};
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_widget_WinMouseScrollHandler_h__
|