зеркало из https://github.com/mozilla/gecko-dev.git
439 строки
14 KiB
C++
439 строки
14 KiB
C++
/* -*- 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/. */
|
|
|
|
/*
|
|
This file provides the implementation for xul popup listener which
|
|
tracks xul popups and context menus
|
|
*/
|
|
|
|
#include "nsXULPopupListener.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsIDOMElement.h"
|
|
#include "nsIDOMXULElement.h"
|
|
#include "nsIDOMNodeList.h"
|
|
#include "nsIDOMDocument.h"
|
|
#include "nsIDOMDocumentXBL.h"
|
|
#include "nsContentCID.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsXULPopupManager.h"
|
|
#include "nsIScriptContext.h"
|
|
#include "nsIDOMWindow.h"
|
|
#include "nsIDOMXULDocument.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsIPrincipal.h"
|
|
#include "nsIScriptSecurityManager.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsHTMLReflowState.h"
|
|
#include "nsIObjectLoadingContent.h"
|
|
#include "mozilla/EventStateManager.h"
|
|
#include "mozilla/EventStates.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/dom/Event.h" // for nsIDOMEvent::InternalDOMEvent()
|
|
#include "mozilla/dom/EventTarget.h"
|
|
#include "mozilla/dom/FragmentOrElement.h"
|
|
|
|
// for event firing in context menus
|
|
#include "nsPresContext.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsFocusManager.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsViewManager.h"
|
|
#include "nsError.h"
|
|
#include "nsMenuFrame.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
// on win32 and os/2, context menus come up on mouse up. On other platforms,
|
|
// they appear on mouse down. Certain bits of code care about this difference.
|
|
#if defined(XP_WIN)
|
|
#define NS_CONTEXT_MENU_IS_MOUSEUP 1
|
|
#endif
|
|
|
|
nsXULPopupListener::nsXULPopupListener(mozilla::dom::Element* aElement,
|
|
bool aIsContext)
|
|
: mElement(aElement), mPopupContent(nullptr), mIsContext(aIsContext)
|
|
{
|
|
}
|
|
|
|
nsXULPopupListener::~nsXULPopupListener(void)
|
|
{
|
|
ClosePopup();
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION(nsXULPopupListener, mElement, mPopupContent)
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsXULPopupListener)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsXULPopupListener)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsXULPopupListener)
|
|
// If the owner, mElement, can be skipped, so can we.
|
|
if (tmp->mElement) {
|
|
return mozilla::dom::FragmentOrElement::CanSkip(tmp->mElement, true);
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsXULPopupListener)
|
|
if (tmp->mElement) {
|
|
return mozilla::dom::FragmentOrElement::CanSkipInCC(tmp->mElement);
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsXULPopupListener)
|
|
if (tmp->mElement) {
|
|
return mozilla::dom::FragmentOrElement::CanSkipThis(tmp->mElement);
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsXULPopupListener)
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
// nsIDOMEventListener
|
|
|
|
nsresult
|
|
nsXULPopupListener::HandleEvent(nsIDOMEvent* aEvent)
|
|
{
|
|
nsAutoString eventType;
|
|
aEvent->GetType(eventType);
|
|
|
|
if(!((eventType.EqualsLiteral("mousedown") && !mIsContext) ||
|
|
(eventType.EqualsLiteral("contextmenu") && mIsContext)))
|
|
return NS_OK;
|
|
|
|
int16_t button;
|
|
|
|
nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
|
|
if (!mouseEvent) {
|
|
//non-ui event passed in. bad things.
|
|
return NS_OK;
|
|
}
|
|
|
|
// Get the node that was clicked on.
|
|
EventTarget* target = mouseEvent->InternalDOMEvent()->GetTarget();
|
|
nsCOMPtr<nsIDOMNode> targetNode = do_QueryInterface(target);
|
|
|
|
if (!targetNode && mIsContext) {
|
|
// Not a DOM node, see if it's the DOM window (bug 380818).
|
|
nsCOMPtr<nsIDOMWindow> domWin = do_QueryInterface(target);
|
|
if (!domWin) {
|
|
return NS_ERROR_DOM_WRONG_TYPE_ERR;
|
|
}
|
|
// Try to use the root node as target node.
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
domWin->GetDocument(getter_AddRefs(domDoc));
|
|
|
|
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
|
|
if (doc)
|
|
targetNode = do_QueryInterface(doc->GetRootElement());
|
|
if (!targetNode) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIContent> targetContent = do_QueryInterface(target);
|
|
if (!targetContent) {
|
|
return NS_OK;
|
|
}
|
|
if (targetContent->IsXULElement(nsGkAtoms::browser) &&
|
|
EventStateManager::IsRemoteTarget(targetContent)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
bool preventDefault;
|
|
mouseEvent->GetDefaultPrevented(&preventDefault);
|
|
if (preventDefault && targetNode && mIsContext) {
|
|
// Someone called preventDefault on a context menu.
|
|
// Let's make sure they are allowed to do so.
|
|
bool eventEnabled =
|
|
Preferences::GetBool("dom.event.contextmenu.enabled", true);
|
|
if (!eventEnabled) {
|
|
// If the target node is for plug-in, we should not open XUL context
|
|
// menu on windowless plug-ins.
|
|
nsCOMPtr<nsIObjectLoadingContent> olc = do_QueryInterface(targetNode);
|
|
uint32_t type;
|
|
if (olc && NS_SUCCEEDED(olc->GetDisplayedType(&type)) &&
|
|
type == nsIObjectLoadingContent::TYPE_PLUGIN) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// The user wants his contextmenus. Let's make sure that this is a website
|
|
// and not chrome since there could be places in chrome which don't want
|
|
// contextmenus.
|
|
nsCOMPtr<nsINode> node = do_QueryInterface(targetNode);
|
|
if (node) {
|
|
nsCOMPtr<nsIPrincipal> system;
|
|
nsContentUtils::GetSecurityManager()->
|
|
GetSystemPrincipal(getter_AddRefs(system));
|
|
if (node->NodePrincipal() != system) {
|
|
// This isn't chrome. Cancel the preventDefault() and
|
|
// let the event go forth.
|
|
preventDefault = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (preventDefault) {
|
|
// someone called preventDefault. bail.
|
|
return NS_OK;
|
|
}
|
|
|
|
// prevent popups on menu and menuitems as they handle their own popups
|
|
// This was added for bug 96920.
|
|
// If a menu item child was clicked on that leads to a popup needing
|
|
// to show, we know (guaranteed) that we're dealing with a menu or
|
|
// submenu of an already-showing popup. We don't need to do anything at all.
|
|
if (!mIsContext) {
|
|
if (targetContent &&
|
|
targetContent->IsAnyOfXULElements(nsGkAtoms::menu, nsGkAtoms::menuitem))
|
|
return NS_OK;
|
|
}
|
|
|
|
if (mIsContext) {
|
|
#ifndef NS_CONTEXT_MENU_IS_MOUSEUP
|
|
// If the context menu launches on mousedown,
|
|
// we have to fire focus on the content we clicked on
|
|
FireFocusOnTargetContent(targetNode);
|
|
#endif
|
|
}
|
|
else {
|
|
// Only open popups when the left mouse button is down.
|
|
mouseEvent->GetButton(&button);
|
|
if (button != 0)
|
|
return NS_OK;
|
|
}
|
|
|
|
// Open the popup. LaunchPopup will call StopPropagation and PreventDefault
|
|
// in the right situations.
|
|
LaunchPopup(aEvent, targetContent);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#ifndef NS_CONTEXT_MENU_IS_MOUSEUP
|
|
nsresult
|
|
nsXULPopupListener::FireFocusOnTargetContent(nsIDOMNode* aTargetNode)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIDOMDocument> domDoc;
|
|
rv = aTargetNode->GetOwnerDocument(getter_AddRefs(domDoc));
|
|
if(NS_SUCCEEDED(rv) && domDoc)
|
|
{
|
|
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
|
|
|
|
// Get nsIDOMElement for targetNode
|
|
nsIPresShell *shell = doc->GetShell();
|
|
if (!shell)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
// strong reference to keep this from going away between events
|
|
// XXXbz between what events? We don't use this local at all!
|
|
RefPtr<nsPresContext> context = shell->GetPresContext();
|
|
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(aTargetNode);
|
|
nsIFrame* targetFrame = content->GetPrimaryFrame();
|
|
if (!targetFrame) return NS_ERROR_FAILURE;
|
|
|
|
const nsStyleUserInterface* ui = targetFrame->StyleUserInterface();
|
|
bool suppressBlur = (ui->mUserFocus == NS_STYLE_USER_FOCUS_IGNORE);
|
|
|
|
nsCOMPtr<nsIDOMElement> element;
|
|
nsCOMPtr<nsIContent> newFocus = do_QueryInterface(content);
|
|
|
|
nsIFrame* currFrame = targetFrame;
|
|
// Look for the nearest enclosing focusable frame.
|
|
while (currFrame) {
|
|
int32_t tabIndexUnused;
|
|
if (currFrame->IsFocusable(&tabIndexUnused, true)) {
|
|
newFocus = currFrame->GetContent();
|
|
nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(newFocus));
|
|
if (domElement) {
|
|
element = domElement;
|
|
break;
|
|
}
|
|
}
|
|
currFrame = currFrame->GetParent();
|
|
}
|
|
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
if (fm) {
|
|
if (element) {
|
|
fm->SetFocus(element, nsIFocusManager::FLAG_BYMOUSE |
|
|
nsIFocusManager::FLAG_NOSCROLL);
|
|
} else if (!suppressBlur) {
|
|
nsPIDOMWindow *window = doc->GetWindow();
|
|
fm->ClearFocus(window);
|
|
}
|
|
}
|
|
|
|
EventStateManager* esm = context->EventStateManager();
|
|
nsCOMPtr<nsIContent> focusableContent = do_QueryInterface(element);
|
|
esm->SetContentState(focusableContent, NS_EVENT_STATE_ACTIVE);
|
|
}
|
|
return rv;
|
|
}
|
|
#endif
|
|
|
|
// ClosePopup
|
|
//
|
|
// Do everything needed to shut down the popup.
|
|
//
|
|
// NOTE: This routine is safe to call even if the popup is already closed.
|
|
//
|
|
void
|
|
nsXULPopupListener::ClosePopup()
|
|
{
|
|
if (mPopupContent) {
|
|
// this is called when the listener is going away, so make sure that the
|
|
// popup is hidden. Use asynchronous hiding just to be safe so we don't
|
|
// fire events during destruction.
|
|
nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
|
|
if (pm)
|
|
pm->HidePopup(mPopupContent, false, true, true, false);
|
|
mPopupContent = nullptr; // release the popup
|
|
}
|
|
} // ClosePopup
|
|
|
|
static already_AddRefed<nsIContent>
|
|
GetImmediateChild(nsIContent* aContent, nsIAtom *aTag)
|
|
{
|
|
for (nsIContent* child = aContent->GetFirstChild();
|
|
child;
|
|
child = child->GetNextSibling()) {
|
|
if (child->IsXULElement(aTag)) {
|
|
nsCOMPtr<nsIContent> ret = child;
|
|
return ret.forget();
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//
|
|
// LaunchPopup
|
|
//
|
|
// Given the element on which the event was triggered and the mouse locations in
|
|
// Client and widget coordinates, popup a new window showing the appropriate
|
|
// content.
|
|
//
|
|
// aTargetContent is the target of the mouse event aEvent that triggered the
|
|
// popup. mElement is the element that the popup menu is attached to.
|
|
// aTargetContent may be equal to mElement or it may be a descendant.
|
|
//
|
|
// This looks for an attribute on |mElement| of the appropriate popup type
|
|
// (popup, context) and uses that attribute's value as an ID for
|
|
// the popup content in the document.
|
|
//
|
|
nsresult
|
|
nsXULPopupListener::LaunchPopup(nsIDOMEvent* aEvent, nsIContent* aTargetContent)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
nsAutoString identifier;
|
|
nsIAtom* type = mIsContext ? nsGkAtoms::context : nsGkAtoms::popup;
|
|
bool hasPopupAttr = mElement->GetAttr(kNameSpaceID_None, type, identifier);
|
|
|
|
if (identifier.IsEmpty()) {
|
|
hasPopupAttr = mElement->GetAttr(kNameSpaceID_None,
|
|
mIsContext ? nsGkAtoms::contextmenu : nsGkAtoms::menu,
|
|
identifier) || hasPopupAttr;
|
|
}
|
|
|
|
if (hasPopupAttr) {
|
|
aEvent->StopPropagation();
|
|
aEvent->PreventDefault();
|
|
}
|
|
|
|
if (identifier.IsEmpty())
|
|
return rv;
|
|
|
|
// Try to find the popup content and the document.
|
|
nsCOMPtr<nsIDocument> document = mElement->GetComposedDoc();
|
|
if (!document) {
|
|
NS_WARNING("No document!");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Handle the _child case for popups and context menus
|
|
nsCOMPtr<nsIContent> popup;
|
|
if (identifier.EqualsLiteral("_child")) {
|
|
popup = GetImmediateChild(mElement, nsGkAtoms::menupopup);
|
|
if (!popup) {
|
|
nsCOMPtr<nsIDOMDocumentXBL> nsDoc(do_QueryInterface(document));
|
|
nsCOMPtr<nsIDOMNodeList> list;
|
|
nsCOMPtr<nsIDOMElement> el = do_QueryInterface(mElement);
|
|
nsDoc->GetAnonymousNodes(el, getter_AddRefs(list));
|
|
if (list) {
|
|
uint32_t ctr,listLength;
|
|
nsCOMPtr<nsIDOMNode> node;
|
|
list->GetLength(&listLength);
|
|
for (ctr = 0; ctr < listLength; ctr++) {
|
|
list->Item(ctr, getter_AddRefs(node));
|
|
nsCOMPtr<nsIContent> childContent(do_QueryInterface(node));
|
|
|
|
if (childContent->NodeInfo()->Equals(nsGkAtoms::menupopup,
|
|
kNameSpaceID_XUL)) {
|
|
popup.swap(childContent);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (!mElement->IsInUncomposedDoc() ||
|
|
!(popup = document->GetElementById(identifier))) {
|
|
// XXXsmaug Should we try to use ShadowRoot::GetElementById in case
|
|
// mElement is in shadow DOM?
|
|
//
|
|
// Use getElementById to obtain the popup content and gracefully fail if
|
|
// we didn't find any popup content in the document.
|
|
NS_WARNING("GetElementById had some kind of spasm.");
|
|
return rv;
|
|
}
|
|
|
|
// return if no popup was found or the popup is the element itself.
|
|
if (!popup || popup == mElement)
|
|
return NS_OK;
|
|
|
|
// Submenus can't be used as context menus or popups, bug 288763.
|
|
// Similar code also in nsXULTooltipListener::GetTooltipFor.
|
|
nsIContent* parent = popup->GetParent();
|
|
if (parent) {
|
|
nsMenuFrame* menu = do_QueryFrame(parent->GetPrimaryFrame());
|
|
if (menu)
|
|
return NS_OK;
|
|
}
|
|
|
|
nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
|
|
if (!pm)
|
|
return NS_OK;
|
|
|
|
// For left-clicks, if the popup has an position attribute, or both the
|
|
// popupanchor and popupalign attributes are used, anchor the popup to the
|
|
// element, otherwise just open it at the screen position where the mouse
|
|
// was clicked. Context menus always open at the mouse position.
|
|
mPopupContent = popup;
|
|
if (!mIsContext &&
|
|
(mPopupContent->HasAttr(kNameSpaceID_None, nsGkAtoms::position) ||
|
|
(mPopupContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popupanchor) &&
|
|
mPopupContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popupalign)))) {
|
|
pm->ShowPopup(mPopupContent, mElement, EmptyString(), 0, 0,
|
|
false, true, false, aEvent);
|
|
}
|
|
else {
|
|
int32_t xPos = 0, yPos = 0;
|
|
nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
|
|
mouseEvent->GetScreenX(&xPos);
|
|
mouseEvent->GetScreenY(&yPos);
|
|
|
|
pm->ShowPopupAtScreen(mPopupContent, xPos, yPos, mIsContext, aEvent);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|