Add m-esr52 at 52.6.0

1 files changed, 542 insertions, 0 deletions

diff --git a/dom/events/MouseEvent.cpp b/dom/events/MouseEvent.cpp
new file mode 100644
index 000000000..5e540ac5b
--- /dev/null
+++ b/dom/events/MouseEvent.cpp
@@ -0,0 +1,542 @@
+/* -*- 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->mTime = PR_Now();
+    mEvent->mRefPoint = LayoutDeviceIntPoint(0, 0);
+    mouseEvent->inputSource = nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN;
+  }
+
+  if (mouseEvent) {
+    MOZ_ASSERT(mouseEvent->mReason != WidgetMouseEvent::eSynthesized,
+               "Don't dispatch DOM events from synthesized mouse events");
+    mDetail = mouseEvent->mClickCount;
+  }
+}
+
+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)
+
+void
+MouseEvent::InitMouseEvent(const nsAString& aType,
+                           bool aCanBubble,
+                           bool aCancelable,
+                           nsGlobalWindow* 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,
+                           EventTarget* aRelatedTarget)
+{
+  NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
+
+  UIEvent::InitUIEvent(aType, aCanBubble, aCancelable, aView, aDetail);
+
+  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->mRefPoint.x = aScreenX;
+      mouseEventBase->mRefPoint.y = aScreenY;
+
+      WidgetMouseEvent* mouseEvent = mEvent->AsMouseEvent();
+      if (mouseEvent) {
+        mouseEvent->mClickCount = aDetail;
+      }
+      break;
+    }
+    default:
+       break;
+  }
+}
+
+NS_IMETHODIMP
+MouseEvent::InitMouseEvent(const nsAString& aType,
+                           bool aCanBubble,
+                           bool aCancelable,
+                           mozIDOMWindow* 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)
+{
+  MouseEvent::InitMouseEvent(aType, aCanBubble, aCancelable,
+                             nsGlobalWindow::Cast(aView), aDetail,
+                             aScreenX, aScreenY,
+                             aClientX, aClientY,
+                             aCtrlKey, aAltKey, aShiftKey,
+                             aMetaKey, aButton,
+                             static_cast<EventTarget *>(aRelatedTarget));
+
+  return NS_OK;
+}
+
+void
+MouseEvent::InitMouseEvent(const nsAString& aType,
+                           bool aCanBubble,
+                           bool aCancelable,
+                           nsGlobalWindow* aView,
+                           int32_t aDetail,
+                           int32_t aScreenX,
+                           int32_t aScreenY,
+                           int32_t aClientX,
+                           int32_t aClientY,
+                           int16_t aButton,
+                           EventTarget* aRelatedTarget,
+                           const nsAString& aModifiersList)
+{
+  NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
+
+  Modifiers modifiers = ComputeModifierState(aModifiersList);
+
+  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);
+
+  switch(mEvent->mClass) {
+    case eMouseEventClass:
+    case eMouseScrollEventClass:
+    case eWheelEventClass:
+    case eDragEventClass:
+    case ePointerEventClass:
+    case eSimpleGestureEventClass:
+      mEvent->AsInputEvent()->mModifiers = modifiers;
+      return;
+    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);
+  e->InitializeExtraMouseEventDictionaryMembers(aParam);
+  e->SetTrusted(trusted);
+  e->SetComposed(aParam.mComposed);
+  return e.forget();
+}
+
+void
+MouseEvent::InitNSMouseEvent(const nsAString& aType,
+                             bool aCanBubble,
+                             bool aCancelable,
+                             nsGlobalWindow* 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,
+                             EventTarget* aRelatedTarget,
+                             float aPressure,
+                             uint16_t aInputSource)
+{
+  NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
+
+  MouseEvent::InitMouseEvent(aType, aCanBubble, aCancelable,
+                             aView, aDetail, aScreenX, aScreenY,
+                             aClientX, aClientY,
+                             aCtrlKey, aAltKey, aShiftKey,
+                             aMetaKey, aButton, aRelatedTarget);
+
+  WidgetMouseEventBase* mouseEventBase = mEvent->AsMouseEventBase();
+  mouseEventBase->pressure = aPressure;
+  mouseEventBase->inputSource = aInputSource;
+}
+
+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->mCurrentTarget);
+
+    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->mRefPoint).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->mRefPoint).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->mRefPoint,
+                                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->mRefPoint,
+                                mClientPoint).y;
+}
+
+int32_t
+MouseEvent::OffsetX()
+{
+  return Event::GetOffsetCoords(mPresContext, mEvent, mEvent->mRefPoint,
+                                mClientPoint).x;
+}
+
+int32_t
+MouseEvent::OffsetY()
+{
+  return Event::GetOffsetCoords(mPresContext, mEvent, mEvent->mRefPoint,
+                                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();
+}