widget/ContentEvents.h
author Noemi Erli <nerli@mozilla.com>
Tue, 26 Feb 2019 03:43:12 +0200
changeset 461110 3c030119c0dcf447dd1afe7165b2d6846a0bc7f0
parent 448947 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Backed out 10 changesets (bug 1505871) for wrench bustages CLOSED TREE Backed out changeset 045ab0ec3613 (bug 1505871) Backed out changeset 6486435a048d (bug 1505871) Backed out changeset 9be871042749 (bug 1505871) Backed out changeset 0007feaf988d (bug 1505871) Backed out changeset 3cb8fb01e77e (bug 1505871) Backed out changeset 2fff213d97e3 (bug 1505871) Backed out changeset 1ad20d485eca (bug 1505871) Backed out changeset 0fd8742fa662 (bug 1505871) Backed out changeset 1899600a7985 (bug 1505871) Backed out changeset f9578d20e54e (bug 1505871)

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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_ContentEvents_h__
#define mozilla_ContentEvents_h__

#include <stdint.h>

#include "mozilla/BasicEvents.h"
#include "mozilla/dom/DataTransfer.h"
#include "mozilla/dom/EventTarget.h"
#include "nsCOMPtr.h"
#include "nsRect.h"
#include "nsString.h"

class nsIContent;

namespace mozilla {

/******************************************************************************
 * mozilla::InternalScrollPortEvent
 ******************************************************************************/

class InternalScrollPortEvent : public WidgetGUIEvent {
 public:
  virtual InternalScrollPortEvent* AsScrollPortEvent() override { return this; }

  enum OrientType { eVertical, eHorizontal, eBoth };

  InternalScrollPortEvent(bool aIsTrusted, EventMessage aMessage,
                          nsIWidget* aWidget)
      : WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eScrollPortEventClass),
        mOrient(eVertical) {}

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eScrollPortEventClass,
               "Duplicate() must be overridden by sub class");
    // Not copying widget, it is a weak reference.
    InternalScrollPortEvent* result =
        new InternalScrollPortEvent(false, mMessage, nullptr);
    result->AssignScrollPortEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  OrientType mOrient;

  void AssignScrollPortEventData(const InternalScrollPortEvent& aEvent,
                                 bool aCopyTargets) {
    AssignGUIEventData(aEvent, aCopyTargets);

    mOrient = aEvent.mOrient;
  }
};

/******************************************************************************
 * mozilla::InternalScrollPortEvent
 ******************************************************************************/

class InternalScrollAreaEvent : public WidgetGUIEvent {
 public:
  virtual InternalScrollAreaEvent* AsScrollAreaEvent() override { return this; }

  InternalScrollAreaEvent(bool aIsTrusted, EventMessage aMessage,
                          nsIWidget* aWidget)
      : WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eScrollAreaEventClass) {}

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eScrollAreaEventClass,
               "Duplicate() must be overridden by sub class");
    // Not copying widget, it is a weak reference.
    InternalScrollAreaEvent* result =
        new InternalScrollAreaEvent(false, mMessage, nullptr);
    result->AssignScrollAreaEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  nsRect mArea;

  void AssignScrollAreaEventData(const InternalScrollAreaEvent& aEvent,
                                 bool aCopyTargets) {
    AssignGUIEventData(aEvent, aCopyTargets);

    mArea = aEvent.mArea;
  }
};

/******************************************************************************
 * mozilla::InternalFormEvent
 *
 * We hold the originating form control for form submit and reset events.
 * mOriginator is a weak pointer (does not hold a strong reference).
 ******************************************************************************/

class InternalFormEvent : public WidgetEvent {
 public:
  virtual InternalFormEvent* AsFormEvent() override { return this; }

  InternalFormEvent(bool aIsTrusted, EventMessage aMessage)
      : WidgetEvent(aIsTrusted, aMessage, eFormEventClass),
        mOriginator(nullptr) {}

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eFormEventClass,
               "Duplicate() must be overridden by sub class");
    InternalFormEvent* result = new InternalFormEvent(false, mMessage);
    result->AssignFormEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  nsIContent* mOriginator;

  void AssignFormEventData(const InternalFormEvent& aEvent, bool aCopyTargets) {
    AssignEventData(aEvent, aCopyTargets);

    // Don't copy mOriginator due to a weak pointer.
  }
};

/******************************************************************************
 * mozilla::InternalClipboardEvent
 ******************************************************************************/

class InternalClipboardEvent : public WidgetEvent {
 public:
  virtual InternalClipboardEvent* AsClipboardEvent() override { return this; }

  InternalClipboardEvent(bool aIsTrusted, EventMessage aMessage)
      : WidgetEvent(aIsTrusted, aMessage, eClipboardEventClass) {}

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eClipboardEventClass,
               "Duplicate() must be overridden by sub class");
    InternalClipboardEvent* result =
        new InternalClipboardEvent(false, mMessage);
    result->AssignClipboardEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  nsCOMPtr<dom::DataTransfer> mClipboardData;

  void AssignClipboardEventData(const InternalClipboardEvent& aEvent,
                                bool aCopyTargets) {
    AssignEventData(aEvent, aCopyTargets);

    mClipboardData = aEvent.mClipboardData;
  }
};

/******************************************************************************
 * mozilla::InternalFocusEvent
 ******************************************************************************/

class InternalFocusEvent : public InternalUIEvent {
 public:
  virtual InternalFocusEvent* AsFocusEvent() override { return this; }

  InternalFocusEvent(bool aIsTrusted, EventMessage aMessage)
      : InternalUIEvent(aIsTrusted, aMessage, eFocusEventClass),
        mFromRaise(false),
        mIsRefocus(false) {}

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eFocusEventClass,
               "Duplicate() must be overridden by sub class");
    InternalFocusEvent* result = new InternalFocusEvent(false, mMessage);
    result->AssignFocusEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  bool mFromRaise;
  bool mIsRefocus;

  void AssignFocusEventData(const InternalFocusEvent& aEvent,
                            bool aCopyTargets) {
    AssignUIEventData(aEvent, aCopyTargets);

    mFromRaise = aEvent.mFromRaise;
    mIsRefocus = aEvent.mIsRefocus;
  }
};

/******************************************************************************
 * mozilla::InternalTransitionEvent
 ******************************************************************************/

class InternalTransitionEvent : public WidgetEvent {
 public:
  virtual InternalTransitionEvent* AsTransitionEvent() override { return this; }

  InternalTransitionEvent(bool aIsTrusted, EventMessage aMessage)
      : WidgetEvent(aIsTrusted, aMessage, eTransitionEventClass),
        mElapsedTime(0.0) {}

  InternalTransitionEvent(const InternalTransitionEvent& aOther) = delete;
  InternalTransitionEvent& operator=(const InternalTransitionEvent& aOther) =
      delete;
  InternalTransitionEvent(InternalTransitionEvent&& aOther) = default;
  InternalTransitionEvent& operator=(InternalTransitionEvent&& aOther) =
      default;

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eTransitionEventClass,
               "Duplicate() must be overridden by sub class");
    InternalTransitionEvent* result =
        new InternalTransitionEvent(false, mMessage);
    result->AssignTransitionEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  nsString mPropertyName;
  nsString mPseudoElement;
  float mElapsedTime;

  void AssignTransitionEventData(const InternalTransitionEvent& aEvent,
                                 bool aCopyTargets) {
    AssignEventData(aEvent, aCopyTargets);

    mPropertyName = aEvent.mPropertyName;
    mElapsedTime = aEvent.mElapsedTime;
    mPseudoElement = aEvent.mPseudoElement;
  }
};

/******************************************************************************
 * mozilla::InternalAnimationEvent
 ******************************************************************************/

class InternalAnimationEvent : public WidgetEvent {
 public:
  virtual InternalAnimationEvent* AsAnimationEvent() override { return this; }

  InternalAnimationEvent(bool aIsTrusted, EventMessage aMessage)
      : WidgetEvent(aIsTrusted, aMessage, eAnimationEventClass),
        mElapsedTime(0.0) {}

  InternalAnimationEvent(const InternalAnimationEvent& aOther) = delete;
  InternalAnimationEvent& operator=(const InternalAnimationEvent& aOther) =
      delete;
  InternalAnimationEvent(InternalAnimationEvent&& aOther) = default;
  InternalAnimationEvent& operator=(InternalAnimationEvent&& aOther) = default;

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eAnimationEventClass,
               "Duplicate() must be overridden by sub class");
    InternalAnimationEvent* result =
        new InternalAnimationEvent(false, mMessage);
    result->AssignAnimationEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  nsString mAnimationName;
  nsString mPseudoElement;
  float mElapsedTime;

  void AssignAnimationEventData(const InternalAnimationEvent& aEvent,
                                bool aCopyTargets) {
    AssignEventData(aEvent, aCopyTargets);

    mAnimationName = aEvent.mAnimationName;
    mElapsedTime = aEvent.mElapsedTime;
    mPseudoElement = aEvent.mPseudoElement;
  }
};

/******************************************************************************
 * mozilla::InternalSMILTimeEvent
 ******************************************************************************/

class InternalSMILTimeEvent : public InternalUIEvent {
 public:
  virtual InternalSMILTimeEvent* AsSMILTimeEvent() override { return this; }

  InternalSMILTimeEvent(bool aIsTrusted, EventMessage aMessage)
      : InternalUIEvent(aIsTrusted, aMessage, eSMILTimeEventClass) {}

  virtual WidgetEvent* Duplicate() const override {
    MOZ_ASSERT(mClass == eSMILTimeEventClass,
               "Duplicate() must be overridden by sub class");
    InternalSMILTimeEvent* result = new InternalSMILTimeEvent(false, mMessage);
    result->AssignSMILTimeEventData(*this, true);
    result->mFlags = mFlags;
    return result;
  }

  void AssignSMILTimeEventData(const InternalSMILTimeEvent& aEvent,
                               bool aCopyTargets) {
    AssignUIEventData(aEvent, aCopyTargets);
  }
};

}  // namespace mozilla

#endif  // mozilla_ContentEvents_h__