mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/dom/xbl/nsXBLWindowKeyHandler.cpp

965 строки
33 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 "nsCOMPtr.h"
#include "nsXBLPrototypeHandler.h"
#include "nsXBLWindowKeyHandler.h"
#include "nsIContent.h"
#include "nsAtom.h"
#include "nsXBLService.h"
#include "nsIServiceManager.h"
#include "nsGkAtoms.h"
#include "nsXBLDocumentInfo.h"
#include "nsIDOMElement.h"
#include "nsFocusManager.h"
#include "nsIURI.h"
#include "nsNetUtil.h"
#include "nsContentUtils.h"
#include "nsXBLPrototypeBinding.h"
#include "nsPIDOMWindow.h"
#include "nsIDocShell.h"
#include "nsIDOMDocument.h"
#include "nsISelectionController.h"
#include "nsIPresShell.h"
#include "mozilla/EventListenerManager.h"
#include "mozilla/EventStateManager.h"
#include "mozilla/HTMLEditor.h"
#include "mozilla/Move.h"
#include "mozilla/Preferences.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/TextEvents.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/KeyboardEvent.h"
#include "mozilla/layers/KeyboardMap.h"
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::layers;
class nsXBLSpecialDocInfo : public nsIObserver
{
public:
RefPtr<nsXBLDocumentInfo> mHTMLBindings;
RefPtr<nsXBLDocumentInfo> mUserHTMLBindings;
static const char sHTMLBindingStr[];
static const char sUserHTMLBindingStr[];
bool mInitialized;
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
void LoadDocInfo();
void GetAllHandlers(const char* aType,
nsXBLPrototypeHandler** handler,
nsXBLPrototypeHandler** userHandler);
void GetHandlers(nsXBLDocumentInfo* aInfo,
const nsACString& aRef,
nsXBLPrototypeHandler** aResult);
nsXBLSpecialDocInfo() : mInitialized(false) {}
protected:
virtual ~nsXBLSpecialDocInfo() {}
};
const char nsXBLSpecialDocInfo::sHTMLBindingStr[] =
"chrome://global/content/platformHTMLBindings.xml";
NS_IMPL_ISUPPORTS(nsXBLSpecialDocInfo, nsIObserver)
NS_IMETHODIMP
nsXBLSpecialDocInfo::Observe(nsISupports* aSubject,
const char* aTopic,
const char16_t* aData)
{
MOZ_ASSERT(!strcmp(aTopic, "xpcom-shutdown"), "wrong topic");
// On shutdown, clear our fields to avoid an extra cycle collection.
mHTMLBindings = nullptr;
mUserHTMLBindings = nullptr;
mInitialized = false;
nsContentUtils::UnregisterShutdownObserver(this);
return NS_OK;
}
void nsXBLSpecialDocInfo::LoadDocInfo()
{
if (mInitialized)
return;
mInitialized = true;
nsContentUtils::RegisterShutdownObserver(this);
nsXBLService* xblService = nsXBLService::GetInstance();
if (!xblService)
return;
// Obtain the platform doc info
nsCOMPtr<nsIURI> bindingURI;
NS_NewURI(getter_AddRefs(bindingURI), sHTMLBindingStr);
if (!bindingURI) {
return;
}
xblService->LoadBindingDocumentInfo(nullptr, nullptr,
bindingURI,
nullptr,
true,
getter_AddRefs(mHTMLBindings));
}
//
// GetHandlers
//
//
void
nsXBLSpecialDocInfo::GetHandlers(nsXBLDocumentInfo* aInfo,
const nsACString& aRef,
nsXBLPrototypeHandler** aResult)
{
nsXBLPrototypeBinding* binding = aInfo->GetPrototypeBinding(aRef);
NS_ASSERTION(binding, "No binding found for the XBL window key handler.");
if (!binding)
return;
*aResult = binding->GetPrototypeHandlers();
}
void
nsXBLSpecialDocInfo::GetAllHandlers(const char* aType,
nsXBLPrototypeHandler** aHandler,
nsXBLPrototypeHandler** aUserHandler)
{
if (mUserHTMLBindings) {
nsAutoCString type(aType);
type.AppendLiteral("User");
GetHandlers(mUserHTMLBindings, type, aUserHandler);
}
if (mHTMLBindings) {
GetHandlers(mHTMLBindings, nsDependentCString(aType), aHandler);
}
}
// Init statics
static StaticRefPtr<nsXBLSpecialDocInfo> sXBLSpecialDocInfo;
uint32_t nsXBLWindowKeyHandler::sRefCnt = 0;
/* static */ void
nsXBLWindowKeyHandler::EnsureSpecialDocInfo()
{
if (!sXBLSpecialDocInfo) {
sXBLSpecialDocInfo = new nsXBLSpecialDocInfo();
}
sXBLSpecialDocInfo->LoadDocInfo();
}
nsXBLWindowKeyHandler::nsXBLWindowKeyHandler(nsIDOMElement* aElement,
EventTarget* aTarget)
: mTarget(aTarget),
mHandler(nullptr),
mUserHandler(nullptr)
{
mWeakPtrForElement = do_GetWeakReference(aElement);
++sRefCnt;
}
nsXBLWindowKeyHandler::~nsXBLWindowKeyHandler()
{
// If mWeakPtrForElement is non-null, we created a prototype handler.
if (mWeakPtrForElement)
delete mHandler;
--sRefCnt;
if (!sRefCnt) {
sXBLSpecialDocInfo = nullptr;
}
}
NS_IMPL_ISUPPORTS(nsXBLWindowKeyHandler,
nsIDOMEventListener)
static void
BuildHandlerChain(nsIContent* aContent, nsXBLPrototypeHandler** aResult)
{
*aResult = nullptr;
// Since we chain each handler onto the next handler,
// we'll enumerate them here in reverse so that when we
// walk the chain they'll come out in the original order
for (nsIContent* key = aContent->GetLastChild();
key;
key = key->GetPreviousSibling()) {
if (!key->NodeInfo()->Equals(nsGkAtoms::key, kNameSpaceID_XUL)) {
continue;
}
Element* keyElement = key->AsElement();
// Check whether the key element has empty value at key/char attribute.
// Such element is used by localizers for alternative shortcut key
// definition on the locale. See bug 426501.
nsAutoString valKey, valCharCode, valKeyCode;
bool attrExists =
keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::key, valKey) ||
keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::charcode, valCharCode) ||
keyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::keycode, valKeyCode);
if (attrExists &&
valKey.IsEmpty() && valCharCode.IsEmpty() && valKeyCode.IsEmpty())
continue;
// reserved="pref" is the default for <key> elements.
XBLReservedKey reserved = XBLReservedKey_Unset;
if (keyElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::reserved,
nsGkAtoms::_true, eCaseMatters)) {
reserved = XBLReservedKey_True;
} else if (keyElement->AttrValueIs(kNameSpaceID_None,
nsGkAtoms::reserved,
nsGkAtoms::_false, eCaseMatters)) {
reserved = XBLReservedKey_False;
}
nsXBLPrototypeHandler* handler =
new nsXBLPrototypeHandler(keyElement, reserved);
handler->SetNextHandler(*aResult);
*aResult = handler;
}
}
//
// EnsureHandlers
//
// Lazily load the XBL handlers. Overridden to handle being attached
// to a particular element rather than the document
//
nsresult
nsXBLWindowKeyHandler::EnsureHandlers()
{
nsCOMPtr<Element> el = GetElement();
NS_ENSURE_STATE(!mWeakPtrForElement || el);
if (el) {
// We are actually a XUL <keyset>.
if (mHandler)
return NS_OK;
nsCOMPtr<nsIContent> content(do_QueryInterface(el));
BuildHandlerChain(content, &mHandler);
} else { // We are an XBL file of handlers.
EnsureSpecialDocInfo();
// Now determine which handlers we should be using.
if (IsHTMLEditableFieldFocused()) {
sXBLSpecialDocInfo->GetAllHandlers("editor", &mHandler, &mUserHandler);
}
else {
sXBLSpecialDocInfo->GetAllHandlers("browser", &mHandler, &mUserHandler);
}
}
return NS_OK;
}
nsresult
nsXBLWindowKeyHandler::WalkHandlers(KeyboardEvent* aKeyEvent, nsAtom* aEventType)
{
if (aKeyEvent->DefaultPrevented()) {
return NS_OK;
}
// Don't process the event if it was not dispatched from a trusted source
if (!aKeyEvent->IsTrusted()) {
return NS_OK;
}
nsresult rv = EnsureHandlers();
NS_ENSURE_SUCCESS(rv, rv);
bool isDisabled;
nsCOMPtr<Element> el = GetElement(&isDisabled);
if (!el) {
if (mUserHandler) {
WalkHandlersInternal(aKeyEvent, aEventType, mUserHandler, true);
if (aKeyEvent->DefaultPrevented()) {
return NS_OK; // Handled by the user bindings. Our work here is done.
}
}
}
// skip keysets that are disabled
if (el && isDisabled) {
return NS_OK;
}
WalkHandlersInternal(aKeyEvent, aEventType, mHandler, true);
return NS_OK;
}
void
nsXBLWindowKeyHandler::InstallKeyboardEventListenersTo(
EventListenerManager* aEventListenerManager)
{
// For marking each keyboard event as if it's reserved by chrome,
// nsXBLWindowKeyHandlers need to listen each keyboard events before
// web contents.
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keydown"),
TrustedEventsAtCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keyup"),
TrustedEventsAtCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keypress"),
TrustedEventsAtCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("mozkeydownonplugin"),
TrustedEventsAtCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("mozkeyuponplugin"),
TrustedEventsAtCapture());
// For reducing the IPC cost, preventing to dispatch reserved keyboard
// events into the content process.
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keydown"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keyup"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keypress"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("mozkeydownonplugin"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("mozkeyuponplugin"),
TrustedEventsAtSystemGroupCapture());
// Handle keyboard events in bubbling phase of the system event group.
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keydown"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keyup"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("keypress"),
TrustedEventsAtSystemGroupBubble());
// mozaccesskeynotfound event is fired when modifiers of keypress event
// matches with modifier of content access key but it's not consumed by
// remote content.
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("mozaccesskeynotfound"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("mozkeydownonplugin"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->AddEventListenerByType(
this, NS_LITERAL_STRING("mozkeyuponplugin"),
TrustedEventsAtSystemGroupBubble());
}
void
nsXBLWindowKeyHandler::RemoveKeyboardEventListenersFrom(
EventListenerManager* aEventListenerManager)
{
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keydown"),
TrustedEventsAtCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keyup"),
TrustedEventsAtCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keypress"),
TrustedEventsAtCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("mozkeydownonplugin"),
TrustedEventsAtCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("mozkeyuponplugin"),
TrustedEventsAtCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keydown"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keyup"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keypress"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("mozkeydownonplugin"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("mozkeyuponplugin"),
TrustedEventsAtSystemGroupCapture());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keydown"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keyup"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("keypress"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("mozaccesskeynotfound"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("mozkeydownonplugin"),
TrustedEventsAtSystemGroupBubble());
aEventListenerManager->RemoveEventListenerByType(
this, NS_LITERAL_STRING("mozkeyuponplugin"),
TrustedEventsAtSystemGroupBubble());
}
/* static */ KeyboardMap
nsXBLWindowKeyHandler::CollectKeyboardShortcuts()
{
// Load the XBL handlers
EnsureSpecialDocInfo();
nsXBLPrototypeHandler* handlers = nullptr;
nsXBLPrototypeHandler* userHandlers = nullptr;
sXBLSpecialDocInfo->GetAllHandlers("browser", &handlers, &userHandlers);
// Convert the handlers into keyboard shortcuts, using an AutoTArray with
// the maximum amount of shortcuts used on any platform to minimize allocations
AutoTArray<KeyboardShortcut, 48> shortcuts;
// Append keyboard shortcuts for hardcoded actions like tab
KeyboardShortcut::AppendHardcodedShortcuts(shortcuts);
for (nsXBLPrototypeHandler* handler = handlers;
handler;
handler = handler->GetNextHandler()) {
KeyboardShortcut shortcut;
if (handler->TryConvertToKeyboardShortcut(&shortcut)) {
shortcuts.AppendElement(shortcut);
}
}
for (nsXBLPrototypeHandler* handler = userHandlers;
handler;
handler = handler->GetNextHandler()) {
KeyboardShortcut shortcut;
if (handler->TryConvertToKeyboardShortcut(&shortcut)) {
shortcuts.AppendElement(shortcut);
}
}
return KeyboardMap(mozilla::Move(shortcuts));
}
nsAtom*
nsXBLWindowKeyHandler::ConvertEventToDOMEventType(
const WidgetKeyboardEvent& aWidgetKeyboardEvent) const
{
if (aWidgetKeyboardEvent.IsKeyDownOrKeyDownOnPlugin()) {
return nsGkAtoms::keydown;
}
if (aWidgetKeyboardEvent.IsKeyUpOrKeyUpOnPlugin()) {
return nsGkAtoms::keyup;
}
// eAccessKeyNotFound event is always created from eKeyPress event and
// the original eKeyPress event has stopped its propagation before dispatched
// into the DOM tree in this process and not matched with remote content's
// access keys. So, we should treat it as an eKeyPress event and execute
// a command if it's registered as a shortcut key.
if (aWidgetKeyboardEvent.mMessage == eKeyPress ||
aWidgetKeyboardEvent.mMessage == eAccessKeyNotFound) {
return nsGkAtoms::keypress;
}
MOZ_ASSERT_UNREACHABLE(
"All event messages which this instance listens to should be handled");
return nullptr;
}
NS_IMETHODIMP
nsXBLWindowKeyHandler::HandleEvent(nsIDOMEvent* aEvent)
{
RefPtr<KeyboardEvent> keyEvent =
aEvent->InternalDOMEvent()->AsKeyboardEvent();
NS_ENSURE_TRUE(keyEvent, NS_ERROR_INVALID_ARG);
uint16_t eventPhase;
aEvent->GetEventPhase(&eventPhase);
if (eventPhase == nsIDOMEvent::CAPTURING_PHASE) {
if (aEvent->WidgetEventPtr()->mFlags.mInSystemGroup) {
HandleEventOnCaptureInSystemEventGroup(keyEvent);
} else {
HandleEventOnCaptureInDefaultEventGroup(keyEvent);
}
return NS_OK;
}
WidgetKeyboardEvent* widgetKeyboardEvent =
aEvent->WidgetEventPtr()->AsKeyboardEvent();
if (widgetKeyboardEvent->IsKeyEventOnPlugin()) {
// key events on plugin shouldn't execute shortcut key handlers which are
// not reserved.
if (!widgetKeyboardEvent->IsReservedByChrome()) {
return NS_OK;
}
// If the event is untrusted event or was already consumed, do nothing.
if (!widgetKeyboardEvent->IsTrusted() ||
widgetKeyboardEvent->DefaultPrevented()) {
return NS_OK;
}
// XXX Don't check isReserved here because even if the handler in this
// instance isn't reserved but another instance reserves the key
// combination, it will be executed when the event is normal keyboard
// events...
bool isReserved = false;
if (!HasHandlerForEvent(keyEvent, &isReserved)) {
return NS_OK;
}
}
// If this event was handled by APZ then don't do the default action, and
// preventDefault to prevent any other listeners from handling the event.
if (widgetKeyboardEvent->mFlags.mHandledByAPZ) {
aEvent->PreventDefault();
return NS_OK;
}
RefPtr<nsAtom> eventTypeAtom =
ConvertEventToDOMEventType(*widgetKeyboardEvent);
return WalkHandlers(keyEvent, eventTypeAtom);
}
void
nsXBLWindowKeyHandler::HandleEventOnCaptureInDefaultEventGroup(
KeyboardEvent* aEvent)
{
WidgetKeyboardEvent* widgetKeyboardEvent =
aEvent->WidgetEventPtr()->AsKeyboardEvent();
if (widgetKeyboardEvent->IsReservedByChrome()) {
return;
}
bool isReserved = false;
if (HasHandlerForEvent(aEvent, &isReserved) && isReserved) {
widgetKeyboardEvent->MarkAsReservedByChrome();
}
}
void
nsXBLWindowKeyHandler::HandleEventOnCaptureInSystemEventGroup(
KeyboardEvent* aEvent)
{
WidgetKeyboardEvent* widgetEvent =
aEvent->WidgetEventPtr()->AsKeyboardEvent();
// If the event won't be sent to remote process, this listener needs to do
// nothing. Note that even if mOnlySystemGroupDispatchInContent is true,
// we need to send the event to remote process and check reply event
// before matching it with registered shortcut keys because event listeners
// in the system event group may want to handle the event before registered
// shortcut key handlers.
if (!widgetEvent->WillBeSentToRemoteProcess()) {
return;
}
if (!HasHandlerForEvent(aEvent)) {
return;
}
// If this event wasn't marked as IsCrossProcessForwardingStopped,
// yet, it means it wasn't processed by content. We'll not call any
// of the handlers at this moment, and will wait the reply event.
// So, stop immediate propagation in this event first, then, mark it as
// waiting reply from remote process. Finally, when this process receives
// a reply from the remote process, it should be dispatched into this
// DOM tree again.
widgetEvent->StopImmediatePropagation();
widgetEvent->MarkAsWaitingReplyFromRemoteProcess();
}
bool
nsXBLWindowKeyHandler::IsHTMLEditableFieldFocused()
{
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
if (!fm)
return false;
nsCOMPtr<mozIDOMWindowProxy> focusedWindow;
fm->GetFocusedWindow(getter_AddRefs(focusedWindow));
if (!focusedWindow)
return false;
auto* piwin = nsPIDOMWindowOuter::From(focusedWindow);
nsIDocShell *docShell = piwin->GetDocShell();
if (!docShell) {
return false;
}
RefPtr<HTMLEditor> htmlEditor = docShell->GetHTMLEditor();
if (!htmlEditor) {
return false;
}
nsCOMPtr<nsIDocument> doc = htmlEditor->GetDocument();
if (doc->HasFlag(NODE_IS_EDITABLE)) {
// Don't need to perform any checks in designMode documents.
return true;
}
nsCOMPtr<nsIDOMElement> focusedElement;
fm->GetFocusedElement(getter_AddRefs(focusedElement));
nsCOMPtr<nsINode> focusedNode = do_QueryInterface(focusedElement);
if (focusedNode) {
// If there is a focused element, make sure it's in the active editing host.
// Note that GetActiveEditingHost finds the current editing host based on
// the document's selection. Even though the document selection is usually
// collapsed to where the focus is, but the page may modify the selection
// without our knowledge, in which case this check will do something useful.
nsCOMPtr<Element> activeEditingHost = htmlEditor->GetActiveEditingHost();
if (!activeEditingHost) {
return false;
}
return nsContentUtils::ContentIsDescendantOf(focusedNode, activeEditingHost);
}
return false;
}
//
// WalkHandlersInternal and WalkHandlersAndExecute
//
// Given a particular DOM event and a pointer to the first handler in the list,
// scan through the list to find something to handle the event. If aExecute = true,
// the handler will be executed; otherwise just return an answer telling if a handler
// for that event was found.
//
bool
nsXBLWindowKeyHandler::WalkHandlersInternal(KeyboardEvent* aKeyEvent,
nsAtom* aEventType,
nsXBLPrototypeHandler* aHandler,
bool aExecute,
bool* aOutReservedForChrome)
{
WidgetKeyboardEvent* nativeKeyboardEvent =
aKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
MOZ_ASSERT(nativeKeyboardEvent);
AutoShortcutKeyCandidateArray shortcutKeys;
nativeKeyboardEvent->GetShortcutKeyCandidates(shortcutKeys);
if (shortcutKeys.IsEmpty()) {
return WalkHandlersAndExecute(aKeyEvent, aEventType, aHandler,
0, IgnoreModifierState(),
aExecute, aOutReservedForChrome);
}
for (uint32_t i = 0; i < shortcutKeys.Length(); ++i) {
ShortcutKeyCandidate& key = shortcutKeys[i];
IgnoreModifierState ignoreModifierState;
ignoreModifierState.mShift = key.mIgnoreShift;
if (WalkHandlersAndExecute(aKeyEvent, aEventType, aHandler,
key.mCharCode, ignoreModifierState,
aExecute, aOutReservedForChrome)) {
return true;
}
}
return false;
}
bool
nsXBLWindowKeyHandler::WalkHandlersAndExecute(
KeyboardEvent* aKeyEvent,
nsAtom* aEventType,
nsXBLPrototypeHandler* aFirstHandler,
uint32_t aCharCode,
const IgnoreModifierState& aIgnoreModifierState,
bool aExecute,
bool* aOutReservedForChrome)
{
if (aOutReservedForChrome) {
*aOutReservedForChrome = false;
}
WidgetKeyboardEvent* widgetKeyboardEvent =
aKeyEvent->WidgetEventPtr()->AsKeyboardEvent();
if (NS_WARN_IF(!widgetKeyboardEvent)) {
return false;
}
// Try all of the handlers until we find one that matches the event.
for (nsXBLPrototypeHandler* handler = aFirstHandler;
handler;
handler = handler->GetNextHandler()) {
bool stopped = aKeyEvent->IsDispatchStopped();
if (stopped) {
// The event is finished, don't execute any more handlers
return false;
}
if (aExecute) {
// If the event is eKeyDownOnPlugin, it should execute either keydown
// handler or keypress handler because eKeyDownOnPlugin events are
// never followed by keypress events.
if (widgetKeyboardEvent->mMessage == eKeyDownOnPlugin) {
if (!handler->EventTypeEquals(nsGkAtoms::keydown) &&
!handler->EventTypeEquals(nsGkAtoms::keypress)) {
continue;
}
// The other event types should exactly be matched with the handler's
// event type.
} else if (!handler->EventTypeEquals(aEventType)) {
continue;
}
} else {
if (handler->EventTypeEquals(nsGkAtoms::keypress)) {
// If the handler is a keypress event handler, we also need to check
// if coming keydown event is a preceding event of reserved key
// combination because if default action of a keydown event is
// prevented, following keypress event won't be fired. However, if
// following keypress event is reserved, we shouldn't allow web
// contents to prevent the default of the preceding keydown event.
if (aEventType != nsGkAtoms::keydown &&
aEventType != nsGkAtoms::keypress) {
continue;
}
} else if (!handler->EventTypeEquals(aEventType)) {
// Otherwise, aEventType should exactly be matched.
continue;
}
}
// Check if the keyboard event *may* execute the handler.
if (!handler->KeyEventMatched(aKeyEvent, aCharCode, aIgnoreModifierState)) {
continue; // try the next one
}
// Before executing this handler, check that it's not disabled,
// and that it has something to do (oncommand of the <key> or its
// <command> is non-empty).
nsCOMPtr<Element> commandElement;
if (!GetElementForHandler(handler, getter_AddRefs(commandElement))) {
continue;
}
if (commandElement) {
if (aExecute && !IsExecutableElement(commandElement)) {
continue;
}
}
if (!aExecute) {
if (handler->EventTypeEquals(aEventType)) {
if (aOutReservedForChrome) {
*aOutReservedForChrome = IsReservedKey(widgetKeyboardEvent, handler);
}
return true;
}
// If the command is reserved and the event is keydown, check also if
// the handler is for keypress because if following keypress event is
// reserved, we shouldn't dispatch the event into web contents.
if (aEventType == nsGkAtoms::keydown &&
handler->EventTypeEquals(nsGkAtoms::keypress)) {
if (IsReservedKey(widgetKeyboardEvent, handler)) {
if (aOutReservedForChrome) {
*aOutReservedForChrome = true;
}
return true;
}
}
// Otherwise, we've not found a handler for the event yet.
continue;
}
// This should only be assigned when aExecute is false.
MOZ_ASSERT(!aOutReservedForChrome);
// If it's not reserved and the event is a key event on a plugin,
// the handler shouldn't be executed.
if (widgetKeyboardEvent->IsKeyEventOnPlugin() &&
!IsReservedKey(widgetKeyboardEvent, handler)) {
return false;
}
nsCOMPtr<EventTarget> target;
nsCOMPtr<Element> chromeHandlerElement = GetElement();
if (chromeHandlerElement) {
// XXX commandElement may be nullptr...
target = commandElement;
} else {
target = mTarget;
}
// XXX Do we execute only one handler even if the handler neither stops
// propagation nor prevents default of the event?
nsresult rv = handler->ExecuteHandler(target, aKeyEvent);
if (NS_SUCCEEDED(rv)) {
return true;
}
}
#ifdef XP_WIN
// Windows native applications ignore Windows-Logo key state when checking
// shortcut keys even if the key is pressed. Therefore, if there is no
// shortcut key which exactly matches current modifier state, we should
// retry to look for a shortcut key without the Windows-Logo key press.
if (!aIgnoreModifierState.mOS && widgetKeyboardEvent->IsOS()) {
IgnoreModifierState ignoreModifierState(aIgnoreModifierState);
ignoreModifierState.mOS = true;
return WalkHandlersAndExecute(aKeyEvent, aEventType, aFirstHandler,
aCharCode, ignoreModifierState, aExecute);
}
#endif
return false;
}
bool
nsXBLWindowKeyHandler::IsReservedKey(WidgetKeyboardEvent* aKeyEvent,
nsXBLPrototypeHandler* aHandler)
{
XBLReservedKey reserved = aHandler->GetIsReserved();
// reserved="true" means that the key is always reserved. reserved="false"
// means that the key is never reserved. Otherwise, we check site-specific
// permissions.
if (reserved == XBLReservedKey_False) {
return false;
}
if (reserved == XBLReservedKey_True) {
return true;
}
return nsContentUtils::ShouldBlockReservedKeys(aKeyEvent);
}
bool
nsXBLWindowKeyHandler::HasHandlerForEvent(KeyboardEvent* aEvent,
bool* aOutReservedForChrome)
{
WidgetKeyboardEvent* widgetKeyboardEvent =
aEvent->WidgetEventPtr()->AsKeyboardEvent();
if (NS_WARN_IF(!widgetKeyboardEvent) || !widgetKeyboardEvent->IsTrusted()) {
return false;
}
nsresult rv = EnsureHandlers();
NS_ENSURE_SUCCESS(rv, false);
bool isDisabled;
nsCOMPtr<Element> el = GetElement(&isDisabled);
if (el && isDisabled) {
return false;
}
RefPtr<nsAtom> eventTypeAtom =
ConvertEventToDOMEventType(*widgetKeyboardEvent);
return WalkHandlersInternal(aEvent, eventTypeAtom, mHandler, false,
aOutReservedForChrome);
}
already_AddRefed<Element>
nsXBLWindowKeyHandler::GetElement(bool* aIsDisabled)
{
nsCOMPtr<Element> element = do_QueryReferent(mWeakPtrForElement);
if (element && aIsDisabled) {
*aIsDisabled = element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
nsGkAtoms::_true, eCaseMatters);
}
return element.forget();
}
bool
nsXBLWindowKeyHandler::GetElementForHandler(nsXBLPrototypeHandler* aHandler,
Element** aElementForHandler)
{
MOZ_ASSERT(aElementForHandler);
*aElementForHandler = nullptr;
RefPtr<Element> keyContent = aHandler->GetHandlerElement();
if (!keyContent) {
return true; // XXX Even though no key element?
}
nsCOMPtr<Element> chromeHandlerElement = GetElement();
if (!chromeHandlerElement) {
NS_WARNING_ASSERTION(keyContent->IsInUncomposedDoc(), "uncomposed");
nsCOMPtr<Element> keyElement = do_QueryInterface(keyContent);
keyElement.swap(*aElementForHandler);
return true;
}
// We are in a XUL doc. Obtain our command attribute.
nsAutoString command;
keyContent->GetAttr(kNameSpaceID_None, nsGkAtoms::command, command);
if (command.IsEmpty()) {
// There is no command element associated with the key element.
NS_WARNING_ASSERTION(keyContent->IsInUncomposedDoc(), "uncomposed");
nsCOMPtr<Element> keyElement = do_QueryInterface(keyContent);
keyElement.swap(*aElementForHandler);
return true;
}
// XXX Shouldn't we check this earlier?
nsIDocument* doc = keyContent->GetUncomposedDoc();
if (NS_WARN_IF(!doc)) {
return false;
}
nsCOMPtr<Element> commandElement =
do_QueryInterface(doc->GetElementById(command));
if (!commandElement) {
NS_ERROR("A XUL <key> is observing a command that doesn't exist. "
"Unable to execute key binding!");
return false;
}
commandElement.swap(*aElementForHandler);
return true;
}
bool
nsXBLWindowKeyHandler::IsExecutableElement(Element* aElement) const
{
if (!aElement) {
return false;
}
nsAutoString value;
aElement->GetAttribute(NS_LITERAL_STRING("disabled"), value);
if (value.EqualsLiteral("true")) {
return false;
}
aElement->GetAttribute(NS_LITERAL_STRING("oncommand"), value);
if (value.IsEmpty()) {
return false;
}
return true;
}
///////////////////////////////////////////////////////////////////////////////////
already_AddRefed<nsXBLWindowKeyHandler>
NS_NewXBLWindowKeyHandler(nsIDOMElement* aElement, EventTarget* aTarget)
{
RefPtr<nsXBLWindowKeyHandler> result =
new nsXBLWindowKeyHandler(aElement, aTarget);
return result.forget();
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку