2015-05-03 22:32:37 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2014-04-01 08:09:22 +04:00
|
|
|
/* 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_WheelHandlingHelper_h_
|
|
|
|
#define mozilla_WheelHandlingHelper_h_
|
|
|
|
|
|
|
|
#include "mozilla/Attributes.h"
|
|
|
|
#include "mozilla/EventForwards.h"
|
|
|
|
#include "nsCoord.h"
|
|
|
|
#include "nsIFrame.h"
|
2015-04-21 18:04:57 +03:00
|
|
|
#include "nsPoint.h"
|
2014-04-01 08:09:22 +04:00
|
|
|
|
|
|
|
class nsIScrollableFrame;
|
|
|
|
class nsITimer;
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
|
2014-04-01 08:09:23 +04:00
|
|
|
class EventStateManager;
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
/**
|
|
|
|
* DeltaValues stores two delta values which are along X and Y axis. This is
|
|
|
|
* useful for arguments and results of some methods.
|
|
|
|
*/
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
struct DeltaValues
|
|
|
|
{
|
|
|
|
DeltaValues()
|
|
|
|
: deltaX(0.0)
|
|
|
|
, deltaY(0.0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
DeltaValues(double aDeltaX, double aDeltaY)
|
|
|
|
: deltaX(aDeltaX)
|
|
|
|
, deltaY(aDeltaY)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit DeltaValues(WidgetWheelEvent* aEvent);
|
|
|
|
|
|
|
|
double deltaX;
|
|
|
|
double deltaY;
|
|
|
|
};
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
/**
|
|
|
|
* WheelHandlingUtils provides some static methods which are useful at handling
|
|
|
|
* wheel events.
|
|
|
|
*/
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
class WheelHandlingUtils
|
|
|
|
{
|
|
|
|
public:
|
2015-10-16 07:19:27 +03:00
|
|
|
/**
|
|
|
|
* Returns true if aFrame is a scrollable frame and it can be scrolled to
|
|
|
|
* either aDirectionX or aDirectionY along each axis. Or if aFrame is a
|
|
|
|
* plugin frame (in this case, aDirectionX and aDirectionY are ignored).
|
|
|
|
* Otherwise, false.
|
|
|
|
*/
|
|
|
|
static bool CanScrollOn(nsIFrame* aFrame,
|
|
|
|
double aDirectionX, double aDirectionY);
|
2014-04-01 08:09:22 +04:00
|
|
|
/**
|
|
|
|
* Returns true if the scrollable frame can be scrolled to either aDirectionX
|
|
|
|
* or aDirectionY along each axis. Otherwise, false.
|
|
|
|
*/
|
|
|
|
static bool CanScrollOn(nsIScrollableFrame* aScrollFrame,
|
|
|
|
double aDirectionX, double aDirectionY);
|
|
|
|
|
2018-02-22 21:40:44 +03:00
|
|
|
// For more details about the concept of a disregarded direction, refer to the
|
|
|
|
// code in struct mozilla::layers::ScrollMetadata which defines
|
|
|
|
// mDisregardedDirection.
|
|
|
|
static Maybe<layers::ScrollDirection>
|
|
|
|
GetDisregardedWheelScrollDirection(const nsIFrame* aFrame);
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
private:
|
|
|
|
static bool CanScrollInRange(nscoord aMin, nscoord aValue, nscoord aMax,
|
|
|
|
double aDirection);
|
|
|
|
};
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
/**
|
|
|
|
* ScrollbarsForWheel manages scrollbars state during wheel operation.
|
|
|
|
* E.g., on some platforms, scrollbars should show only while user attempts to
|
|
|
|
* scroll. At that time, scrollbars which may be possible to scroll by
|
|
|
|
* operation of wheel at the point should show temporarily.
|
|
|
|
*/
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
class ScrollbarsForWheel
|
2014-04-01 08:09:22 +04:00
|
|
|
{
|
|
|
|
public:
|
2014-04-01 08:09:23 +04:00
|
|
|
static void PrepareToScrollText(EventStateManager* aESM,
|
2014-04-01 08:09:22 +04:00
|
|
|
nsIFrame* aTargetFrame,
|
2014-04-01 08:09:22 +04:00
|
|
|
WidgetWheelEvent* aEvent);
|
2014-04-01 08:09:22 +04:00
|
|
|
static void SetActiveScrollTarget(nsIScrollableFrame* aScrollTarget);
|
|
|
|
// Hide all scrollbars (both mActiveOwner's and mActivatedScrollTargets')
|
|
|
|
static void MayInactivate();
|
|
|
|
static void Inactivate();
|
|
|
|
static bool IsActive();
|
|
|
|
static void OwnWheelTransaction(bool aOwn);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static const size_t kNumberOfTargets = 4;
|
2014-04-01 08:09:22 +04:00
|
|
|
static const DeltaValues directions[kNumberOfTargets];
|
2017-03-01 20:03:14 +03:00
|
|
|
static AutoWeakFrame sActiveOwner;
|
|
|
|
static AutoWeakFrame sActivatedScrollTargets[kNumberOfTargets];
|
2014-04-01 08:09:22 +04:00
|
|
|
static bool sHadWheelStart;
|
|
|
|
static bool sOwnWheelTransaction;
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2015-09-10 19:59:55 +03:00
|
|
|
* These two methods are called upon eWheelOperationStart/eWheelOperationEnd
|
|
|
|
* events to show/hide the right scrollbars.
|
2014-04-01 08:09:22 +04:00
|
|
|
*/
|
|
|
|
static void TemporarilyActivateAllPossibleScrollTargets(
|
2014-04-01 08:09:23 +04:00
|
|
|
EventStateManager* aESM,
|
2014-04-01 08:09:22 +04:00
|
|
|
nsIFrame* aTargetFrame,
|
2014-04-01 08:09:22 +04:00
|
|
|
WidgetWheelEvent* aEvent);
|
2014-04-01 08:09:22 +04:00
|
|
|
static void DeactivateAllTemporarilyActivatedScrollTargets();
|
|
|
|
};
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
/**
|
|
|
|
* WheelTransaction manages a series of wheel events as a transaction.
|
|
|
|
* While in a transaction, every wheel event should scroll the same scrollable
|
|
|
|
* element even if a different scrollable element is under the mouse cursor.
|
|
|
|
*
|
|
|
|
* Additionally, this class also manages wheel scroll speed acceleration.
|
|
|
|
*/
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
class WheelTransaction
|
2014-04-01 08:09:22 +04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
static nsIFrame* GetTargetFrame() { return sTargetFrame; }
|
|
|
|
static void EndTransaction();
|
2015-10-16 07:19:27 +03:00
|
|
|
/**
|
|
|
|
* WillHandleDefaultAction() is called before handling aWheelEvent on
|
|
|
|
* aTargetFrame.
|
|
|
|
*
|
|
|
|
* @return false if the caller cannot continue to handle the default
|
|
|
|
* action. Otherwise, true.
|
2017-07-06 15:00:35 +03:00
|
|
|
*/
|
2015-10-16 07:19:27 +03:00
|
|
|
static bool WillHandleDefaultAction(WidgetWheelEvent* aWheelEvent,
|
2017-03-01 20:03:14 +03:00
|
|
|
AutoWeakFrame& aTargetWeakFrame);
|
2015-10-16 07:19:27 +03:00
|
|
|
static bool WillHandleDefaultAction(WidgetWheelEvent* aWheelEvent,
|
|
|
|
nsIFrame* aTargetFrame)
|
|
|
|
{
|
2017-03-01 20:03:14 +03:00
|
|
|
AutoWeakFrame targetWeakFrame(aTargetFrame);
|
2015-10-16 07:19:27 +03:00
|
|
|
return WillHandleDefaultAction(aWheelEvent, targetWeakFrame);
|
|
|
|
}
|
2014-04-01 08:09:22 +04:00
|
|
|
static void OnEvent(WidgetEvent* aEvent);
|
2014-04-01 08:09:22 +04:00
|
|
|
static void Shutdown();
|
2017-04-13 05:41:23 +03:00
|
|
|
static uint32_t GetTimeoutTime()
|
|
|
|
{
|
|
|
|
return Prefs::sMouseWheelTransactionTimeout;
|
|
|
|
}
|
2014-04-01 08:09:22 +04:00
|
|
|
|
|
|
|
static void OwnScrollbars(bool aOwn);
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
static DeltaValues AccelerateWheelDelta(WidgetWheelEvent* aEvent,
|
|
|
|
bool aAllowScrollSpeedOverride);
|
2017-04-13 05:41:23 +03:00
|
|
|
static void InitializeStatics()
|
|
|
|
{
|
|
|
|
Prefs::InitializeStatics();
|
|
|
|
}
|
2014-04-01 08:09:22 +04:00
|
|
|
|
|
|
|
protected:
|
2015-10-16 07:19:27 +03:00
|
|
|
static void BeginTransaction(nsIFrame* aTargetFrame,
|
2018-02-22 21:40:44 +03:00
|
|
|
const WidgetWheelEvent* aEvent);
|
2015-10-16 07:19:27 +03:00
|
|
|
// Be careful, UpdateTransaction may fire a DOM event, therefore, the target
|
|
|
|
// frame might be destroyed in the event handler.
|
2018-02-22 21:40:44 +03:00
|
|
|
static bool UpdateTransaction(const WidgetWheelEvent* aEvent);
|
2015-10-16 07:19:27 +03:00
|
|
|
static void MayEndTransaction();
|
|
|
|
|
2017-04-25 01:33:13 +03:00
|
|
|
static LayoutDeviceIntPoint GetScreenPoint(WidgetGUIEvent* aEvent);
|
2014-04-01 08:09:22 +04:00
|
|
|
static void OnFailToScrollTarget();
|
|
|
|
static void OnTimeout(nsITimer* aTimer, void* aClosure);
|
|
|
|
static void SetTimeout();
|
2017-04-13 05:41:23 +03:00
|
|
|
static uint32_t GetIgnoreMoveDelayTime()
|
|
|
|
{
|
|
|
|
return Prefs::sMouseWheelTransactionIgnoreMoveDelay;
|
|
|
|
}
|
|
|
|
static int32_t GetAccelerationStart()
|
|
|
|
{
|
|
|
|
return Prefs::sMouseWheelAccelerationStart;
|
|
|
|
}
|
|
|
|
static int32_t GetAccelerationFactor()
|
|
|
|
{
|
|
|
|
return Prefs::sMouseWheelAccelerationFactor;
|
|
|
|
}
|
2014-04-01 08:09:22 +04:00
|
|
|
static DeltaValues OverrideSystemScrollSpeed(WidgetWheelEvent* aEvent);
|
2014-04-01 08:09:22 +04:00
|
|
|
static double ComputeAcceleratedWheelDelta(double aDelta, int32_t aFactor);
|
|
|
|
static bool OutOfTime(uint32_t aBaseTime, uint32_t aThreshold);
|
|
|
|
|
2017-03-01 20:03:14 +03:00
|
|
|
static AutoWeakFrame sTargetFrame;
|
2014-04-01 08:09:22 +04:00
|
|
|
static uint32_t sTime; // in milliseconds
|
|
|
|
static uint32_t sMouseMoved; // in milliseconds
|
|
|
|
static nsITimer* sTimer;
|
|
|
|
static int32_t sScrollSeriesCounter;
|
|
|
|
static bool sOwnScrollbars;
|
2017-04-13 05:41:23 +03:00
|
|
|
|
|
|
|
class Prefs
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
static void InitializeStatics();
|
|
|
|
static int32_t sMouseWheelAccelerationStart;
|
|
|
|
static int32_t sMouseWheelAccelerationFactor;
|
|
|
|
static uint32_t sMouseWheelTransactionTimeout;
|
|
|
|
static uint32_t sMouseWheelTransactionIgnoreMoveDelay;
|
|
|
|
static bool sTestMouseScroll;
|
|
|
|
};
|
2014-04-01 08:09:22 +04:00
|
|
|
};
|
|
|
|
|
2018-03-15 11:31:07 +03:00
|
|
|
// For some kinds of scrollings, the delta values of WidgetWheelEvent are
|
|
|
|
// possbile to be adjusted. For example, the user has configured the pref to let
|
|
|
|
// [vertical wheel + Shift key] to perform horizontal scrolling instead of
|
|
|
|
// vertical scrolling.
|
|
|
|
// The values in this enumeration list all kinds of scrollings whose delta
|
|
|
|
// values are possible to be adjusted.
|
|
|
|
enum class WheelDeltaAdjustmentStrategy : uint8_t
|
|
|
|
{
|
|
|
|
// There is no strategy, don't adjust delta values in any cases.
|
|
|
|
eNone,
|
|
|
|
// This strategy means we're receiving a horizontalized scroll, so we should
|
|
|
|
// apply horizontalization strategy for its delta values.
|
|
|
|
// Horizontalized scrolling means treating vertical wheel scrolling as
|
|
|
|
// horizontal scrolling by adjusting delta values.
|
|
|
|
// It's important to keep in mind with the percise concept of horizontalized
|
|
|
|
// scrolling: Delta values are *ONLY* going to be adjusted during the process
|
|
|
|
// of its default action handling; in views of any programmes other than the
|
|
|
|
// default action handler, such as a DOM event listener or a plugin, delta
|
|
|
|
// values are never going to be adjusted, they will still retrive original
|
|
|
|
// delta values when horizontalization occured for default actions.
|
|
|
|
eHorizontalize,
|
|
|
|
// TODO A new value for auto-dir scrolling is going to be added while
|
|
|
|
// implementing such scrolling.
|
|
|
|
};
|
|
|
|
|
Bug 143038 Make users can scroll contents horizontally with vertical wheel operation with a modifier r=smaug
This patch declares a new default action, "horizontal scroll", this scrolls
content horizontally with deltaY of wheel events and ignores deltaX and deltaZ.
This is used for default action with Shift key in default setting except on
macOS. On macOS, legacy mouse's vertical wheel operation with Shift key causes
native horizontal wheel event. Therefore, we don't need to use this new
default action on macOS. Additionally, old default action with Shift key,
navigating history, is moved to with Alt key. This makes same settings between
macOS and the others. So, this is better for users who use macOS and another
OS and web app developers who check wheel events only on macOS or other
platform(s).
For simpler implementation, default action handlers moves deltaY values to
deltaX values temporarily *only* while they handle wheel events. This is
performed by AutoWheelDeltaAdjuster and restored after handling it
automatically.
So, in other words, even if default action is "horizontal scroll", web apps
receives wheel events whose deltaY is not zero but its content will be
scrolled horizontally. This is same as Chromium, so, this behavior shouldn't
cause any incompatible behavior with it.
MozReview-Commit-ID: E4X3yZzLEAl
--HG--
extra : rebase_source : e20d854c6b0a181ad4c9e7304bd9ad14256481ff
2017-10-04 19:12:35 +03:00
|
|
|
/**
|
2018-03-15 11:31:07 +03:00
|
|
|
* When a *pure* vertical wheel event should be treated as if it was a
|
|
|
|
* horizontal scroll because the user wants to horizontalize the wheel scroll,
|
|
|
|
* an instance of this class will adjust the delta values upon calling
|
|
|
|
* Horizontalize(). And the horizontalized delta values will be restored
|
|
|
|
* automatically when the instance of this class is being destructed. Or you can
|
|
|
|
* restore them in advance by calling CancelHorizontalization().
|
Bug 143038 Make users can scroll contents horizontally with vertical wheel operation with a modifier r=smaug
This patch declares a new default action, "horizontal scroll", this scrolls
content horizontally with deltaY of wheel events and ignores deltaX and deltaZ.
This is used for default action with Shift key in default setting except on
macOS. On macOS, legacy mouse's vertical wheel operation with Shift key causes
native horizontal wheel event. Therefore, we don't need to use this new
default action on macOS. Additionally, old default action with Shift key,
navigating history, is moved to with Alt key. This makes same settings between
macOS and the others. So, this is better for users who use macOS and another
OS and web app developers who check wheel events only on macOS or other
platform(s).
For simpler implementation, default action handlers moves deltaY values to
deltaX values temporarily *only* while they handle wheel events. This is
performed by AutoWheelDeltaAdjuster and restored after handling it
automatically.
So, in other words, even if default action is "horizontal scroll", web apps
receives wheel events whose deltaY is not zero but its content will be
scrolled horizontally. This is same as Chromium, so, this behavior shouldn't
cause any incompatible behavior with it.
MozReview-Commit-ID: E4X3yZzLEAl
--HG--
extra : rebase_source : e20d854c6b0a181ad4c9e7304bd9ad14256481ff
2017-10-04 19:12:35 +03:00
|
|
|
*/
|
2018-03-15 11:31:07 +03:00
|
|
|
class MOZ_STACK_CLASS WheelDeltaHorizontalizer final
|
Bug 143038 Make users can scroll contents horizontally with vertical wheel operation with a modifier r=smaug
This patch declares a new default action, "horizontal scroll", this scrolls
content horizontally with deltaY of wheel events and ignores deltaX and deltaZ.
This is used for default action with Shift key in default setting except on
macOS. On macOS, legacy mouse's vertical wheel operation with Shift key causes
native horizontal wheel event. Therefore, we don't need to use this new
default action on macOS. Additionally, old default action with Shift key,
navigating history, is moved to with Alt key. This makes same settings between
macOS and the others. So, this is better for users who use macOS and another
OS and web app developers who check wheel events only on macOS or other
platform(s).
For simpler implementation, default action handlers moves deltaY values to
deltaX values temporarily *only* while they handle wheel events. This is
performed by AutoWheelDeltaAdjuster and restored after handling it
automatically.
So, in other words, even if default action is "horizontal scroll", web apps
receives wheel events whose deltaY is not zero but its content will be
scrolled horizontally. This is same as Chromium, so, this behavior shouldn't
cause any incompatible behavior with it.
MozReview-Commit-ID: E4X3yZzLEAl
--HG--
extra : rebase_source : e20d854c6b0a181ad4c9e7304bd9ad14256481ff
2017-10-04 19:12:35 +03:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
2018-03-15 11:31:07 +03:00
|
|
|
* @param aWheelEvent A wheel event whose delta values will be adjusted
|
|
|
|
* upon calling Horizontalize().
|
|
|
|
*/
|
|
|
|
explicit WheelDeltaHorizontalizer(WidgetWheelEvent& aWheelEvent)
|
|
|
|
: mWheelEvent(aWheelEvent)
|
|
|
|
, mHorizontalized(false)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Converts vertical scrolling into horizontal scrolling by adjusting the
|
|
|
|
* its delta values.
|
Bug 143038 Make users can scroll contents horizontally with vertical wheel operation with a modifier r=smaug
This patch declares a new default action, "horizontal scroll", this scrolls
content horizontally with deltaY of wheel events and ignores deltaX and deltaZ.
This is used for default action with Shift key in default setting except on
macOS. On macOS, legacy mouse's vertical wheel operation with Shift key causes
native horizontal wheel event. Therefore, we don't need to use this new
default action on macOS. Additionally, old default action with Shift key,
navigating history, is moved to with Alt key. This makes same settings between
macOS and the others. So, this is better for users who use macOS and another
OS and web app developers who check wheel events only on macOS or other
platform(s).
For simpler implementation, default action handlers moves deltaY values to
deltaX values temporarily *only* while they handle wheel events. This is
performed by AutoWheelDeltaAdjuster and restored after handling it
automatically.
So, in other words, even if default action is "horizontal scroll", web apps
receives wheel events whose deltaY is not zero but its content will be
scrolled horizontally. This is same as Chromium, so, this behavior shouldn't
cause any incompatible behavior with it.
MozReview-Commit-ID: E4X3yZzLEAl
--HG--
extra : rebase_source : e20d854c6b0a181ad4c9e7304bd9ad14256481ff
2017-10-04 19:12:35 +03:00
|
|
|
*/
|
2018-03-15 11:31:07 +03:00
|
|
|
void Horizontalize();
|
|
|
|
~WheelDeltaHorizontalizer();
|
|
|
|
void CancelHorizontalization();
|
Bug 143038 Make users can scroll contents horizontally with vertical wheel operation with a modifier r=smaug
This patch declares a new default action, "horizontal scroll", this scrolls
content horizontally with deltaY of wheel events and ignores deltaX and deltaZ.
This is used for default action with Shift key in default setting except on
macOS. On macOS, legacy mouse's vertical wheel operation with Shift key causes
native horizontal wheel event. Therefore, we don't need to use this new
default action on macOS. Additionally, old default action with Shift key,
navigating history, is moved to with Alt key. This makes same settings between
macOS and the others. So, this is better for users who use macOS and another
OS and web app developers who check wheel events only on macOS or other
platform(s).
For simpler implementation, default action handlers moves deltaY values to
deltaX values temporarily *only* while they handle wheel events. This is
performed by AutoWheelDeltaAdjuster and restored after handling it
automatically.
So, in other words, even if default action is "horizontal scroll", web apps
receives wheel events whose deltaY is not zero but its content will be
scrolled horizontally. This is same as Chromium, so, this behavior shouldn't
cause any incompatible behavior with it.
MozReview-Commit-ID: E4X3yZzLEAl
--HG--
extra : rebase_source : e20d854c6b0a181ad4c9e7304bd9ad14256481ff
2017-10-04 19:12:35 +03:00
|
|
|
|
|
|
|
private:
|
|
|
|
WidgetWheelEvent& mWheelEvent;
|
|
|
|
double mOldDeltaX;
|
|
|
|
double mOldDeltaZ;
|
|
|
|
double mOldOverflowDeltaX;
|
|
|
|
int32_t mOldLineOrPageDeltaX;
|
2018-03-15 11:31:07 +03:00
|
|
|
bool mHorizontalized;
|
Bug 143038 Make users can scroll contents horizontally with vertical wheel operation with a modifier r=smaug
This patch declares a new default action, "horizontal scroll", this scrolls
content horizontally with deltaY of wheel events and ignores deltaX and deltaZ.
This is used for default action with Shift key in default setting except on
macOS. On macOS, legacy mouse's vertical wheel operation with Shift key causes
native horizontal wheel event. Therefore, we don't need to use this new
default action on macOS. Additionally, old default action with Shift key,
navigating history, is moved to with Alt key. This makes same settings between
macOS and the others. So, this is better for users who use macOS and another
OS and web app developers who check wheel events only on macOS or other
platform(s).
For simpler implementation, default action handlers moves deltaY values to
deltaX values temporarily *only* while they handle wheel events. This is
performed by AutoWheelDeltaAdjuster and restored after handling it
automatically.
So, in other words, even if default action is "horizontal scroll", web apps
receives wheel events whose deltaY is not zero but its content will be
scrolled horizontally. This is same as Chromium, so, this behavior shouldn't
cause any incompatible behavior with it.
MozReview-Commit-ID: E4X3yZzLEAl
--HG--
extra : rebase_source : e20d854c6b0a181ad4c9e7304bd9ad14256481ff
2017-10-04 19:12:35 +03:00
|
|
|
};
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
} // namespace mozilla
|
|
|
|
|
2014-04-01 08:09:22 +04:00
|
|
|
#endif // mozilla_WheelHandlingHelper_h_
|