mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
9c5965b035
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout. The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.
CLOSED TREE makes big refactorings like this a piece of cake.
# The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
xargs perl -p -i -e '
s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
s/nsRefPtr ?</RefPtr</g; # handle declarations and variables
'
# Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h
# Handle nsRefPtr.h itself, a couple places that define constructors
# from nsRefPtr, and code generators specially. We do this here, rather
# than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
# things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
mfbt/nsRefPtr.h \
xpcom/glue/nsCOMPtr.h \
xpcom/base/OwningNonNull.h \
ipc/ipdl/ipdl/lower.py \
ipc/ipdl/ipdl/builtin.py \
dom/bindings/Codegen.py \
python/lldbutils/lldbutils/utils.py
# In our indiscriminate substitution above, we renamed
# nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'
if [ -d .git ]; then
git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi
516 lines
13 KiB
C++
516 lines
13 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=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/. */
|
|
|
|
#include "mozilla/dom/MouseEvent.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIContent.h"
|
|
#include "prtime.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
MouseEvent::MouseEvent(EventTarget* aOwner,
|
|
nsPresContext* aPresContext,
|
|
WidgetMouseEventBase* aEvent)
|
|
: UIEvent(aOwner, aPresContext,
|
|
aEvent ? aEvent :
|
|
new WidgetMouseEvent(false, eVoidEvent, nullptr,
|
|
WidgetMouseEvent::eReal))
|
|
{
|
|
// There's no way to make this class' ctor allocate an WidgetMouseScrollEvent.
|
|
// It's not that important, though, since a scroll event is not a real
|
|
// DOM event.
|
|
|
|
WidgetMouseEvent* mouseEvent = mEvent->AsMouseEvent();
|
|
if (aEvent) {
|
|
mEventIsInternal = false;
|
|
}
|
|
else {
|
|
mEventIsInternal = true;
|
|
mEvent->time = PR_Now();
|
|
mEvent->refPoint.x = mEvent->refPoint.y = 0;
|
|
mouseEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN;
|
|
}
|
|
|
|
if (mouseEvent) {
|
|
MOZ_ASSERT(mouseEvent->reason != WidgetMouseEvent::eSynthesized,
|
|
"Don't dispatch DOM events from synthesized mouse events");
|
|
mDetail = mouseEvent->clickCount;
|
|
}
|
|
}
|
|
|
|
NS_IMPL_ADDREF_INHERITED(MouseEvent, UIEvent)
|
|
NS_IMPL_RELEASE_INHERITED(MouseEvent, UIEvent)
|
|
|
|
NS_INTERFACE_MAP_BEGIN(MouseEvent)
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMMouseEvent)
|
|
NS_INTERFACE_MAP_END_INHERITING(UIEvent)
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::InitMouseEvent(const nsAString& aType,
|
|
bool aCanBubble,
|
|
bool aCancelable,
|
|
nsIDOMWindow* aView,
|
|
int32_t aDetail,
|
|
int32_t aScreenX,
|
|
int32_t aScreenY,
|
|
int32_t aClientX,
|
|
int32_t aClientY,
|
|
bool aCtrlKey,
|
|
bool aAltKey,
|
|
bool aShiftKey,
|
|
bool aMetaKey,
|
|
uint16_t aButton,
|
|
nsIDOMEventTarget* aRelatedTarget)
|
|
{
|
|
nsresult rv =
|
|
UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, aDetail);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
switch(mEvent->mClass) {
|
|
case eMouseEventClass:
|
|
case eMouseScrollEventClass:
|
|
case eWheelEventClass:
|
|
case eDragEventClass:
|
|
case ePointerEventClass:
|
|
case eSimpleGestureEventClass: {
|
|
WidgetMouseEventBase* mouseEventBase = mEvent->AsMouseEventBase();
|
|
mouseEventBase->relatedTarget = aRelatedTarget;
|
|
mouseEventBase->button = aButton;
|
|
mouseEventBase->InitBasicModifiers(aCtrlKey, aAltKey, aShiftKey, aMetaKey);
|
|
mClientPoint.x = aClientX;
|
|
mClientPoint.y = aClientY;
|
|
mouseEventBase->refPoint.x = aScreenX;
|
|
mouseEventBase->refPoint.y = aScreenY;
|
|
|
|
WidgetMouseEvent* mouseEvent = mEvent->AsMouseEvent();
|
|
if (mouseEvent) {
|
|
mouseEvent->clickCount = aDetail;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
MouseEvent::InitMouseEvent(const nsAString& aType,
|
|
bool aCanBubble,
|
|
bool aCancelable,
|
|
nsIDOMWindow* aView,
|
|
int32_t aDetail,
|
|
int32_t aScreenX,
|
|
int32_t aScreenY,
|
|
int32_t aClientX,
|
|
int32_t aClientY,
|
|
int16_t aButton,
|
|
nsIDOMEventTarget* aRelatedTarget,
|
|
const nsAString& aModifiersList)
|
|
{
|
|
Modifiers modifiers = ComputeModifierState(aModifiersList);
|
|
|
|
nsresult rv = InitMouseEvent(aType, aCanBubble, aCancelable, aView,
|
|
aDetail, aScreenX, aScreenY, aClientX, aClientY,
|
|
(modifiers & MODIFIER_CONTROL) != 0,
|
|
(modifiers & MODIFIER_ALT) != 0,
|
|
(modifiers & MODIFIER_SHIFT) != 0,
|
|
(modifiers & MODIFIER_META) != 0,
|
|
aButton, aRelatedTarget);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
switch(mEvent->mClass) {
|
|
case eMouseEventClass:
|
|
case eMouseScrollEventClass:
|
|
case eWheelEventClass:
|
|
case eDragEventClass:
|
|
case ePointerEventClass:
|
|
case eSimpleGestureEventClass:
|
|
mEvent->AsInputEvent()->modifiers = modifiers;
|
|
return NS_OK;
|
|
default:
|
|
MOZ_CRASH("There is no space to store the modifiers");
|
|
}
|
|
}
|
|
|
|
void
|
|
MouseEvent::InitializeExtraMouseEventDictionaryMembers(const MouseEventInit& aParam)
|
|
{
|
|
InitModifiers(aParam);
|
|
mEvent->AsMouseEventBase()->buttons = aParam.mButtons;
|
|
mMovementPoint.x = aParam.mMovementX;
|
|
mMovementPoint.y = aParam.mMovementY;
|
|
}
|
|
|
|
already_AddRefed<MouseEvent>
|
|
MouseEvent::Constructor(const GlobalObject& aGlobal,
|
|
const nsAString& aType,
|
|
const MouseEventInit& aParam,
|
|
ErrorResult& aRv)
|
|
{
|
|
nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
|
|
RefPtr<MouseEvent> e = new MouseEvent(t, nullptr, nullptr);
|
|
bool trusted = e->Init(t);
|
|
e->InitMouseEvent(aType, aParam.mBubbles, aParam.mCancelable,
|
|
aParam.mView, aParam.mDetail, aParam.mScreenX,
|
|
aParam.mScreenY, aParam.mClientX, aParam.mClientY,
|
|
aParam.mCtrlKey, aParam.mAltKey, aParam.mShiftKey,
|
|
aParam.mMetaKey, aParam.mButton, aParam.mRelatedTarget,
|
|
aRv);
|
|
e->InitializeExtraMouseEventDictionaryMembers(aParam);
|
|
e->SetTrusted(trusted);
|
|
|
|
return e.forget();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::InitNSMouseEvent(const nsAString& aType,
|
|
bool aCanBubble,
|
|
bool aCancelable,
|
|
nsIDOMWindow* aView,
|
|
int32_t aDetail,
|
|
int32_t aScreenX,
|
|
int32_t aScreenY,
|
|
int32_t aClientX,
|
|
int32_t aClientY,
|
|
bool aCtrlKey,
|
|
bool aAltKey,
|
|
bool aShiftKey,
|
|
bool aMetaKey,
|
|
uint16_t aButton,
|
|
nsIDOMEventTarget* aRelatedTarget,
|
|
float aPressure,
|
|
uint16_t aInputSource)
|
|
{
|
|
nsresult rv = MouseEvent::InitMouseEvent(aType, aCanBubble, aCancelable,
|
|
aView, aDetail, aScreenX, aScreenY,
|
|
aClientX, aClientY,
|
|
aCtrlKey, aAltKey, aShiftKey,
|
|
aMetaKey, aButton, aRelatedTarget);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
WidgetMouseEventBase* mouseEventBase = mEvent->AsMouseEventBase();
|
|
mouseEventBase->pressure = aPressure;
|
|
mouseEventBase->inputSource = aInputSource;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetButton(int16_t* aButton)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aButton);
|
|
*aButton = Button();
|
|
return NS_OK;
|
|
}
|
|
|
|
int16_t
|
|
MouseEvent::Button()
|
|
{
|
|
switch(mEvent->mClass) {
|
|
case eMouseEventClass:
|
|
case eMouseScrollEventClass:
|
|
case eWheelEventClass:
|
|
case eDragEventClass:
|
|
case ePointerEventClass:
|
|
case eSimpleGestureEventClass:
|
|
return mEvent->AsMouseEventBase()->button;
|
|
default:
|
|
NS_WARNING("Tried to get mouse button for non-mouse event!");
|
|
return WidgetMouseEvent::eLeftButton;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetButtons(uint16_t* aButtons)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aButtons);
|
|
*aButtons = Buttons();
|
|
return NS_OK;
|
|
}
|
|
|
|
uint16_t
|
|
MouseEvent::Buttons()
|
|
{
|
|
switch(mEvent->mClass) {
|
|
case eMouseEventClass:
|
|
case eMouseScrollEventClass:
|
|
case eWheelEventClass:
|
|
case eDragEventClass:
|
|
case ePointerEventClass:
|
|
case eSimpleGestureEventClass:
|
|
return mEvent->AsMouseEventBase()->buttons;
|
|
default:
|
|
MOZ_CRASH("Tried to get mouse buttons for non-mouse event!");
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetRelatedTarget(nsIDOMEventTarget** aRelatedTarget)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aRelatedTarget);
|
|
*aRelatedTarget = GetRelatedTarget().take();
|
|
return NS_OK;
|
|
}
|
|
|
|
already_AddRefed<EventTarget>
|
|
MouseEvent::GetRelatedTarget()
|
|
{
|
|
nsCOMPtr<EventTarget> relatedTarget;
|
|
switch(mEvent->mClass) {
|
|
case eMouseEventClass:
|
|
case eMouseScrollEventClass:
|
|
case eWheelEventClass:
|
|
case eDragEventClass:
|
|
case ePointerEventClass:
|
|
case eSimpleGestureEventClass:
|
|
relatedTarget =
|
|
do_QueryInterface(mEvent->AsMouseEventBase()->relatedTarget);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (relatedTarget) {
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(relatedTarget);
|
|
nsCOMPtr<nsIContent> currentTarget = do_QueryInterface(mEvent->currentTarget);
|
|
|
|
nsIContent* shadowRelatedTarget = GetShadowRelatedTarget(currentTarget, content);
|
|
if (shadowRelatedTarget) {
|
|
relatedTarget = shadowRelatedTarget;
|
|
}
|
|
|
|
if (content && content->ChromeOnlyAccess() &&
|
|
!nsContentUtils::CanAccessNativeAnon()) {
|
|
relatedTarget = do_QueryInterface(content->FindFirstNonChromeOnlyAccessContent());
|
|
}
|
|
|
|
if (relatedTarget) {
|
|
relatedTarget = relatedTarget->GetTargetForDOMEvent();
|
|
}
|
|
return relatedTarget.forget();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
MouseEvent::GetRegion(nsAString& aRegion)
|
|
{
|
|
SetDOMStringToNull(aRegion);
|
|
WidgetMouseEventBase* mouseEventBase = mEvent->AsMouseEventBase();
|
|
if (mouseEventBase) {
|
|
aRegion = mouseEventBase->region;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetMozMovementX(int32_t* aMovementX)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aMovementX);
|
|
*aMovementX = MovementX();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetMozMovementY(int32_t* aMovementY)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aMovementY);
|
|
*aMovementY = MovementY();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetScreenX(int32_t* aScreenX)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aScreenX);
|
|
*aScreenX = ScreenX();
|
|
return NS_OK;
|
|
}
|
|
|
|
int32_t
|
|
MouseEvent::ScreenX()
|
|
{
|
|
return Event::GetScreenCoords(mPresContext, mEvent, mEvent->refPoint).x;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetScreenY(int32_t* aScreenY)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aScreenY);
|
|
*aScreenY = ScreenY();
|
|
return NS_OK;
|
|
}
|
|
|
|
int32_t
|
|
MouseEvent::ScreenY()
|
|
{
|
|
return Event::GetScreenCoords(mPresContext, mEvent, mEvent->refPoint).y;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetClientX(int32_t* aClientX)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aClientX);
|
|
*aClientX = ClientX();
|
|
return NS_OK;
|
|
}
|
|
|
|
int32_t
|
|
MouseEvent::ClientX()
|
|
{
|
|
return Event::GetClientCoords(mPresContext, mEvent, mEvent->refPoint,
|
|
mClientPoint).x;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetClientY(int32_t* aClientY)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aClientY);
|
|
*aClientY = ClientY();
|
|
return NS_OK;
|
|
}
|
|
|
|
int32_t
|
|
MouseEvent::ClientY()
|
|
{
|
|
return Event::GetClientCoords(mPresContext, mEvent, mEvent->refPoint,
|
|
mClientPoint).y;
|
|
}
|
|
|
|
int32_t
|
|
MouseEvent::OffsetX()
|
|
{
|
|
return Event::GetOffsetCoords(mPresContext, mEvent, mEvent->refPoint,
|
|
mClientPoint).x;
|
|
}
|
|
|
|
int32_t
|
|
MouseEvent::OffsetY()
|
|
{
|
|
return Event::GetOffsetCoords(mPresContext, mEvent, mEvent->refPoint,
|
|
mClientPoint).y;
|
|
}
|
|
|
|
bool
|
|
MouseEvent::AltKey()
|
|
{
|
|
return mEvent->AsInputEvent()->IsAlt();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetAltKey(bool* aIsDown)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aIsDown);
|
|
*aIsDown = AltKey();
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
MouseEvent::CtrlKey()
|
|
{
|
|
return mEvent->AsInputEvent()->IsControl();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetCtrlKey(bool* aIsDown)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aIsDown);
|
|
*aIsDown = CtrlKey();
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
MouseEvent::ShiftKey()
|
|
{
|
|
return mEvent->AsInputEvent()->IsShift();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetShiftKey(bool* aIsDown)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aIsDown);
|
|
*aIsDown = ShiftKey();
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
MouseEvent::MetaKey()
|
|
{
|
|
return mEvent->AsInputEvent()->IsMeta();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetMetaKey(bool* aIsDown)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aIsDown);
|
|
*aIsDown = MetaKey();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetModifierState(const nsAString& aKey,
|
|
bool* aState)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aState);
|
|
|
|
*aState = GetModifierState(aKey);
|
|
return NS_OK;
|
|
}
|
|
|
|
float
|
|
MouseEvent::MozPressure() const
|
|
{
|
|
return mEvent->AsMouseEventBase()->pressure;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetMozPressure(float* aPressure)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aPressure);
|
|
*aPressure = MozPressure();
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
MouseEvent::HitCluster() const
|
|
{
|
|
return mEvent->AsMouseEventBase()->hitCluster;
|
|
}
|
|
|
|
uint16_t
|
|
MouseEvent::MozInputSource() const
|
|
{
|
|
return mEvent->AsMouseEventBase()->inputSource;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
MouseEvent::GetMozInputSource(uint16_t* aInputSource)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aInputSource);
|
|
*aInputSource = MozInputSource();
|
|
return NS_OK;
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
already_AddRefed<MouseEvent>
|
|
NS_NewDOMMouseEvent(EventTarget* aOwner,
|
|
nsPresContext* aPresContext,
|
|
WidgetMouseEvent* aEvent)
|
|
{
|
|
RefPtr<MouseEvent> it = new MouseEvent(aOwner, aPresContext, aEvent);
|
|
return it.forget();
|
|
}
|