dom/events/Event.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_dom_Event_h_
   7 #define mozilla_dom_Event_h_
   8
   9 #include "mozilla/Attributes.h"
  10 #include "mozilla/BasicEvents.h"
  11 #include "nsIDOMEvent.h"
  12 #include "nsISupports.h"
  13 #include "nsCOMPtr.h"
  14 #include "nsPIDOMWindow.h"
  15 #include "nsPoint.h"
  16 #include "nsCycleCollectionParticipant.h"
  17 #include "nsAutoPtr.h"
  18 #include "mozilla/dom/EventBinding.h"
  19 #include "nsIScriptGlobalObject.h"
  20 #include "Units.h"
  21 #include "js/TypeDecls.h"
  22
  23 class nsIContent;
  24 class nsIDOMEventTarget;
  25 class nsPresContext;
  26
  27 namespace mozilla {
  28 namespace dom {
  29
  30 class EventTarget;
  31 class ErrorEvent;
  32 class ProgressEvent;
  33
  34 // Dummy class so we can cast through it to get from nsISupports to
  35 // Event subclasses with only two non-ambiguous static casts.
  36 class EventBase : public nsIDOMEvent
  37 {
  38 };
  39
  40 class Event : public EventBase,
  41               public nsWrapperCache
  42 {
  43 public:
  44   Event(EventTarget* aOwner,
  45         nsPresContext* aPresContext,
  46         WidgetEvent* aEvent);
  47   Event(nsPIDOMWindow* aWindow);
  48   virtual ~Event();
  49
  50 private:
  51   void ConstructorInit(EventTarget* aOwner,
  52                        nsPresContext* aPresContext,
  53                        WidgetEvent* aEvent);
  54
  55 public:
  56   void GetParentObject(nsIScriptGlobalObject** aParentObject)
  57   {
  58     if (mOwner) {
  59       CallQueryInterface(mOwner, aParentObject);
  60     } else {
  61       *aParentObject = nullptr;
  62     }
  63   }
  64
  65   static Event* FromSupports(nsISupports* aSupports)
  66   {
  67     nsIDOMEvent* event =
  68       static_cast<nsIDOMEvent*>(aSupports);
  69 #ifdef DEBUG
  70     {
  71       nsCOMPtr<nsIDOMEvent> target_qi =
  72         do_QueryInterface(aSupports);
  73
  74       // If this assertion fires the QI implementation for the object in
  75       // question doesn't use the nsIDOMEvent pointer as the
  76       // nsISupports pointer. That must be fixed, or we'll crash...
  77       MOZ_ASSERT(target_qi == event, "Uh, fix QI!");
  78     }
  79 #endif
  80     return static_cast<Event*>(event);
  81   }
  82
  83   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  84   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Event)
  85
  86   nsISupports* GetParentObject()
  87   {
  88     return mOwner;
  89   }
  90
  91   virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE
  92   {
  93     return EventBinding::Wrap(aCx, this);
  94   }
  95
  96   virtual ErrorEvent* AsErrorEvent()
  97   {
  98     return nullptr;
  99   }
 100
 101   virtual ProgressEvent* AsProgressEvent()
 102   {
 103     return nullptr;
 104   }
 105
 106   // nsIDOMEvent Interface
 107   NS_DECL_NSIDOMEVENT
 108
 109   void InitPresContextData(nsPresContext* aPresContext);
 110
 111   // Returns true if the event should be trusted.
 112   bool Init(EventTarget* aGlobal);
 113
 114   static PopupControlState GetEventPopupControlState(WidgetEvent* aEvent);
 115
 116   static void PopupAllowedEventsChanged();
 117
 118   static void Shutdown();
 119
 120   static const char* GetEventName(uint32_t aEventType);
 121   static CSSIntPoint GetClientCoords(nsPresContext* aPresContext,
 122                                      WidgetEvent* aEvent,
 123                                      LayoutDeviceIntPoint aPoint,
 124                                      CSSIntPoint aDefaultPoint);
 125   static CSSIntPoint GetPageCoords(nsPresContext* aPresContext,
 126                                    WidgetEvent* aEvent,
 127                                    LayoutDeviceIntPoint aPoint,
 128                                    CSSIntPoint aDefaultPoint);
 129   static nsIntPoint GetScreenCoords(nsPresContext* aPresContext,
 130                                     WidgetEvent* aEvent,
 131                                     LayoutDeviceIntPoint aPoint);
 132
 133   static already_AddRefed<Event> Constructor(const GlobalObject& aGlobal,
 134                                              const nsAString& aType,
 135                                              const EventInit& aParam,
 136                                              ErrorResult& aRv);
 137
 138   // Implemented as xpidl method
 139   // void GetType(nsString& aRetval) {}
 140
 141   EventTarget* GetTarget() const;
 142   EventTarget* GetCurrentTarget() const;
 143
 144   uint16_t EventPhase() const;
 145
 146   // xpidl implementation
 147   // void StopPropagation();
 148
 149   // xpidl implementation
 150   // void StopImmediatePropagation();
 151
 152   bool Bubbles() const
 153   {
 154     return mEvent->mFlags.mBubbles;
 155   }
 156
 157   bool Cancelable() const
 158   {
 159     return mEvent->mFlags.mCancelable;
 160   }
 161
 162   // xpidl implementation
 163   // void PreventDefault();
 164
 165   // You MUST NOT call PreventDefaultJ(JSContext*) from C++ code.  A call of
 166   // this method always sets Event.defaultPrevented true for web contents.
 167   // If default action handler calls this, web applications meet wrong
 168   // defaultPrevented value.
 169   void PreventDefault(JSContext* aCx);
 170
 171   // You MUST NOT call DefaultPrevented(JSContext*) from C++ code.  This may
 172   // return false even if PreventDefault() has been called.
 173   // See comments in its implementation for the detail.
 174   bool DefaultPrevented(JSContext* aCx) const;
 175
 176   bool DefaultPrevented() const
 177   {
 178     return mEvent->mFlags.mDefaultPrevented;
 179   }
 180
 181   bool MultipleActionsPrevented() const
 182   {
 183     return mEvent->mFlags.mMultipleActionsPrevented;
 184   }
 185
 186   bool IsTrusted() const
 187   {
 188     return mEvent->mFlags.mIsTrusted;
 189   }
 190
 191   bool IsSynthesized() const
 192   {
 193     return mEvent->mFlags.mIsSynthesizedForTests;
 194   }
 195
 196   double TimeStamp() const;
 197
 198   void InitEvent(const nsAString& aType, bool aBubbles, bool aCancelable,
 199                  ErrorResult& aRv)
 200   {
 201     aRv = InitEvent(aType, aBubbles, aCancelable);
 202   }
 203
 204   EventTarget* GetOriginalTarget() const;
 205   EventTarget* GetExplicitOriginalTarget() const;
 206
 207   bool GetPreventDefault() const;
 208
 209   /**
 210    * @param aCalledByDefaultHandler     Should be true when this is called by
 211    *                                    C++ or Chrome.  Otherwise, e.g., called
 212    *                                    by a call of Event.preventDefault() in
 213    *                                    content script, false.
 214    */
 215   void PreventDefaultInternal(bool aCalledByDefaultHandler);
 216
 217   bool IsMainThreadEvent()
 218   {
 219     return mIsMainThreadEvent;
 220   }
 221
 222 protected:
 223
 224   // Internal helper functions
 225   void SetEventType(const nsAString& aEventTypeArg);
 226   already_AddRefed<nsIContent> GetTargetFromFrame();
 227
 228   /**
 229    * IsChrome() returns true if aCx is chrome context or the event is created
 230    * in chrome's thread.  Otherwise, false.
 231    */
 232   bool IsChrome(JSContext* aCx) const;
 233
 234   mozilla::WidgetEvent*       mEvent;
 235   nsRefPtr<nsPresContext>     mPresContext;
 236   nsCOMPtr<EventTarget>       mExplicitOriginalTarget;
 237   nsCOMPtr<nsPIDOMWindow>     mOwner; // nsPIDOMWindow for now.
 238   bool                        mEventIsInternal;
 239   bool                        mPrivateDataDuplicated;
 240   bool                        mIsMainThreadEvent;
 241 };
 242
 243 } // namespace dom
 244 } // namespace mozilla
 245
 246 #define NS_FORWARD_TO_EVENT \
 247   NS_FORWARD_NSIDOMEVENT(Event::)
 248
 249 #define NS_FORWARD_NSIDOMEVENT_NO_SERIALIZATION_NO_DUPLICATION(_to) \
 250   NS_IMETHOD GetType(nsAString& aType){ return _to GetType(aType); } \
 251   NS_IMETHOD GetTarget(nsIDOMEventTarget * *aTarget) { return _to GetTarget(aTarget); } \
 252   NS_IMETHOD GetCurrentTarget(nsIDOMEventTarget * *aCurrentTarget) { return _to GetCurrentTarget(aCurrentTarget); } \
 253   NS_IMETHOD GetEventPhase(uint16_t *aEventPhase) { return _to GetEventPhase(aEventPhase); } \
 254   NS_IMETHOD GetBubbles(bool *aBubbles) { return _to GetBubbles(aBubbles); } \
 255   NS_IMETHOD GetCancelable(bool *aCancelable) { return _to GetCancelable(aCancelable); } \
 256   NS_IMETHOD GetTimeStamp(DOMTimeStamp *aTimeStamp) { return _to GetTimeStamp(aTimeStamp); } \
 257   NS_IMETHOD StopPropagation(void) { return _to StopPropagation(); } \
 258   NS_IMETHOD PreventDefault(void) { return _to PreventDefault(); } \
 259   NS_IMETHOD InitEvent(const nsAString & eventTypeArg, bool canBubbleArg, bool cancelableArg) { return _to InitEvent(eventTypeArg, canBubbleArg, cancelableArg); } \
 260   NS_IMETHOD GetDefaultPrevented(bool *aDefaultPrevented) { return _to GetDefaultPrevented(aDefaultPrevented); } \
 261   NS_IMETHOD StopImmediatePropagation(void) { return _to StopImmediatePropagation(); } \
 262   NS_IMETHOD GetOriginalTarget(nsIDOMEventTarget** aOriginalTarget) { return _to GetOriginalTarget(aOriginalTarget); } \
 263   NS_IMETHOD GetExplicitOriginalTarget(nsIDOMEventTarget** aExplicitOriginalTarget) { return _to GetExplicitOriginalTarget(aExplicitOriginalTarget); } \
 264   NS_IMETHOD GetPreventDefault(bool* aRetval) { return _to GetPreventDefault(aRetval); } \
 265   NS_IMETHOD GetIsTrusted(bool* aIsTrusted) { return _to GetIsTrusted(aIsTrusted); } \
 266   NS_IMETHOD SetTarget(nsIDOMEventTarget *aTarget) { return _to SetTarget(aTarget); } \
 267   NS_IMETHOD_(bool) IsDispatchStopped(void) { return _to IsDispatchStopped(); } \
 268   NS_IMETHOD_(WidgetEvent*) GetInternalNSEvent(void) { return _to GetInternalNSEvent(); } \
 269   NS_IMETHOD_(void) SetTrusted(bool aTrusted) { _to SetTrusted(aTrusted); } \
 270   NS_IMETHOD_(void) SetOwner(EventTarget* aOwner) { _to SetOwner(aOwner); } \
 271   NS_IMETHOD_(Event*) InternalDOMEvent() { return _to InternalDOMEvent(); }
 272
 273 #define NS_FORWARD_TO_EVENT_NO_SERIALIZATION_NO_DUPLICATION \
 274   NS_FORWARD_NSIDOMEVENT_NO_SERIALIZATION_NO_DUPLICATION(Event::)
 275
 276 inline nsISupports*
 277 ToSupports(mozilla::dom::Event* e)
 278 {
 279   return static_cast<nsIDOMEvent*>(e);
 280 }
 281
 282 inline nsISupports*
 283 ToCanonicalSupports(mozilla::dom::Event* e)
 284 {
 285   return static_cast<nsIDOMEvent*>(e);
 286 }
 287
 288 #endif // mozilla_dom_Event_h_