From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/xbl/nsXBLPrototypeHandler.h | 243 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 243 insertions(+) create mode 100644 dom/xbl/nsXBLPrototypeHandler.h (limited to 'dom/xbl/nsXBLPrototypeHandler.h') diff --git a/dom/xbl/nsXBLPrototypeHandler.h b/dom/xbl/nsXBLPrototypeHandler.h new file mode 100644 index 000000000..6898b73ed --- /dev/null +++ b/dom/xbl/nsXBLPrototypeHandler.h @@ -0,0 +1,243 @@ +/* -*- 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/. */ + +#ifndef nsXBLPrototypeHandler_h__ +#define nsXBLPrototypeHandler_h__ + +#include "nsIAtom.h" +#include "nsString.h" +#include "nsCOMPtr.h" +#include "nsIController.h" +#include "nsAutoPtr.h" +#include "nsXBLEventHandler.h" +#include "nsIWeakReference.h" +#include "nsCycleCollectionParticipant.h" +#include "js/TypeDecls.h" + +class nsIDOMEvent; +class nsIContent; +class nsIDOMUIEvent; +class nsIDOMKeyEvent; +class nsIDOMMouseEvent; +class nsIObjectInputStream; +class nsIObjectOutputStream; +class nsXBLPrototypeBinding; + +namespace mozilla { +namespace dom { +class AutoJSAPI; +class EventTarget; +} // namespace dom +} // namespace mozilla + +#define NS_HANDLER_TYPE_XBL_JS (1 << 0) +#define NS_HANDLER_TYPE_XBL_COMMAND (1 << 1) +#define NS_HANDLER_TYPE_XUL (1 << 2) +#define NS_HANDLER_HAS_ALLOW_UNTRUSTED_ATTR (1 << 4) +#define NS_HANDLER_ALLOW_UNTRUSTED (1 << 5) +#define NS_HANDLER_TYPE_SYSTEM (1 << 6) +#define NS_HANDLER_TYPE_PREVENTDEFAULT (1 << 7) + +// XXX Use nsIDOMEvent:: codes? +#define NS_PHASE_CAPTURING 1 +#define NS_PHASE_TARGET 2 +#define NS_PHASE_BUBBLING 3 + +namespace mozilla { +namespace dom { + +struct IgnoreModifierState +{ + // When mShift is true, Shift key state will be ignored. + bool mShift; + // When mOS is true, OS key state will be ignored. + bool mOS; + + IgnoreModifierState() + : mShift(false) + , mOS(false) + { + } +}; + +} // namespace dom +} // namespace mozilla + +class nsXBLPrototypeHandler +{ + typedef mozilla::dom::IgnoreModifierState IgnoreModifierState; + +public: + // This constructor is used by XBL handlers (both the JS and command shorthand variety) + nsXBLPrototypeHandler(const char16_t* aEvent, const char16_t* aPhase, + const char16_t* aAction, const char16_t* aCommand, + const char16_t* aKeyCode, const char16_t* aCharCode, + const char16_t* aModifiers, const char16_t* aButton, + const char16_t* aClickCount, const char16_t* aGroup, + const char16_t* aPreventDefault, + const char16_t* aAllowUntrusted, + nsXBLPrototypeBinding* aBinding, + uint32_t aLineNumber); + + // This constructor is used only by XUL key handlers (e.g., ) + explicit nsXBLPrototypeHandler(nsIContent* aKeyElement); + + // This constructor is used for handlers loaded from the cache + explicit nsXBLPrototypeHandler(nsXBLPrototypeBinding* aBinding); + + ~nsXBLPrototypeHandler(); + + bool EventTypeEquals(nsIAtom* aEventType) const + { + return mEventName == aEventType; + } + + // if aCharCode is not zero, it is used instead of the charCode of aKeyEvent. + bool KeyEventMatched(nsIDOMKeyEvent* aKeyEvent, + uint32_t aCharCode, + const IgnoreModifierState& aIgnoreModifierState); + + bool MouseEventMatched(nsIDOMMouseEvent* aMouseEvent); + inline bool MouseEventMatched(nsIAtom* aEventType, + nsIDOMMouseEvent* aEvent) + { + if (!EventTypeEquals(aEventType)) { + return false; + } + return MouseEventMatched(aEvent); + } + + already_AddRefed GetHandlerElement(); + + void AppendHandlerText(const nsAString& aText); + + uint8_t GetPhase() { return mPhase; } + uint8_t GetType() { return mType; } + + nsXBLPrototypeHandler* GetNextHandler() { return mNextHandler; } + void SetNextHandler(nsXBLPrototypeHandler* aHandler) { mNextHandler = aHandler; } + + nsresult ExecuteHandler(mozilla::dom::EventTarget* aTarget, nsIDOMEvent* aEvent); + + already_AddRefed GetEventName(); + void SetEventName(nsIAtom* aName) { mEventName = aName; } + + nsXBLEventHandler* GetEventHandler() + { + if (!mHandler) { + mHandler = NS_NewXBLEventHandler(this, mEventName); + } + + return mHandler; + } + + nsXBLEventHandler* GetCachedEventHandler() + { + return mHandler; + } + + bool HasAllowUntrustedAttr() + { + return (mType & NS_HANDLER_HAS_ALLOW_UNTRUSTED_ATTR) != 0; + } + + // This returns a valid value only if HasAllowUntrustedEventsAttr returns + // true. + bool AllowUntrustedEvents() + { + return (mType & NS_HANDLER_ALLOW_UNTRUSTED) != 0; + } + + nsresult Read(nsIObjectInputStream* aStream); + nsresult Write(nsIObjectOutputStream* aStream); + +public: + static uint32_t gRefCnt; + +protected: + void Init() { + ++gRefCnt; + if (gRefCnt == 1) + // Get the primary accelerator key. + InitAccessKeys(); + } + + already_AddRefed GetController(mozilla::dom::EventTarget* aTarget); + + inline int32_t GetMatchingKeyCode(const nsAString& aKeyName); + void ConstructPrototype(nsIContent* aKeyElement, + const char16_t* aEvent=nullptr, const char16_t* aPhase=nullptr, + const char16_t* aAction=nullptr, const char16_t* aCommand=nullptr, + const char16_t* aKeyCode=nullptr, const char16_t* aCharCode=nullptr, + const char16_t* aModifiers=nullptr, const char16_t* aButton=nullptr, + const char16_t* aClickCount=nullptr, const char16_t* aGroup=nullptr, + const char16_t* aPreventDefault=nullptr, + const char16_t* aAllowUntrusted=nullptr); + + void ReportKeyConflict(const char16_t* aKey, const char16_t* aModifiers, nsIContent* aElement, const char *aMessageName); + void GetEventType(nsAString& type); + bool ModifiersMatchMask(nsIDOMUIEvent* aEvent, + const IgnoreModifierState& aIgnoreModifierState); + nsresult DispatchXBLCommand(mozilla::dom::EventTarget* aTarget, nsIDOMEvent* aEvent); + nsresult DispatchXULKeyCommand(nsIDOMEvent* aEvent); + nsresult EnsureEventHandler(mozilla::dom::AutoJSAPI& jsapi, nsIAtom* aName, + JS::MutableHandle aHandler); + static int32_t KeyToMask(int32_t key); + static int32_t AccelKeyMask(); + + static int32_t kMenuAccessKey; + static void InitAccessKeys(); + + static const int32_t cShift; + static const int32_t cAlt; + static const int32_t cControl; + static const int32_t cMeta; + static const int32_t cOS; + + static const int32_t cShiftMask; + static const int32_t cAltMask; + static const int32_t cControlMask; + static const int32_t cMetaMask; + static const int32_t cOSMask; + + static const int32_t cAllModifiers; + +protected: + union { + nsIWeakReference* mHandlerElement; // For XUL element handlers. [STRONG] + char16_t* mHandlerText; // For XBL handlers (we don't build an + // element for the , and instead + // we cache the JS text or command name + // that we should use. + }; + + uint32_t mLineNumber; // The line number we started at in the XBL file + + // The following four values make up 32 bits. + uint8_t mPhase; // The phase (capturing, bubbling) + uint8_t mType; // The type of the handler. The handler is either a XUL key + // handler, an XBL "command" event, or a normal XBL event with + // accompanying JavaScript. The high bit is used to indicate + // whether this handler should prevent the default action. + uint8_t mMisc; // Miscellaneous extra information. For key events, + // stores whether or not we're a key code or char code. + // For mouse events, stores the clickCount. + + int32_t mKeyMask; // Which modifier keys this event handler expects to have down + // in order to be matched. + + // The primary filter information for mouse/key events. + int32_t mDetail; // For key events, contains a charcode or keycode. For + // mouse events, stores the button info. + + // Prototype handlers are chained. We own the next handler in the chain. + nsXBLPrototypeHandler* mNextHandler; + nsCOMPtr mEventName; // The type of the event, e.g., "keypress" + RefPtr mHandler; + nsXBLPrototypeBinding* mPrototypeBinding; // the binding owns us +}; + +#endif -- cgit v1.2.3