The Tor Browser: comparison layout/xul/nsXULPopupManager.cpp

--1:000000000000
+:186f2bf3047a
+/* -*- 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/. */
+#include "nsGkAtoms.h"
+#include "nsXULPopupManager.h"
+#include "nsMenuFrame.h"
+#include "nsMenuPopupFrame.h"
+#include "nsMenuBarFrame.h"
+#include "nsIPopupBoxObject.h"
+#include "nsMenuBarListener.h"
+#include "nsContentUtils.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMEvent.h"
+#include "nsIDOMXULElement.h"
+#include "nsIXULDocument.h"
+#include "nsIXULTemplateBuilder.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsLayoutUtils.h"
+#include "nsViewManager.h"
+#include "nsIComponentManager.h"
+#include "nsITimer.h"
+#include "nsFocusManager.h"
+#include "nsIDocShell.h"
+#include "nsPIDOMWindow.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIBaseWindow.h"
+#include "nsIDOMKeyEvent.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsCaret.h"
+#include "nsIDocument.h"
+#include "nsPIWindowRoot.h"
+#include "nsFrameManager.h"
+#include "nsIObserverService.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h" // for nsIDOMEvent::InternalDOMEvent()
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Services.h"
+using namespace mozilla;
+using namespace mozilla::dom;
+static_assert(nsIDOMKeyEvent::DOM_VK_HOME  == nsIDOMKeyEvent::DOM_VK_END + 1 &&
+nsIDOMKeyEvent::DOM_VK_LEFT  == nsIDOMKeyEvent::DOM_VK_END + 2 &&
+nsIDOMKeyEvent::DOM_VK_UP    == nsIDOMKeyEvent::DOM_VK_END + 3 &&
+nsIDOMKeyEvent::DOM_VK_RIGHT == nsIDOMKeyEvent::DOM_VK_END + 4 &&
+nsIDOMKeyEvent::DOM_VK_DOWN  == nsIDOMKeyEvent::DOM_VK_END + 5,
+"nsXULPopupManager assumes some keyCode values are consecutive");
+const nsNavigationDirection DirectionFromKeyCodeTable[2][6] = {
+{
+eNavigationDirection_Last,   // nsIDOMKeyEvent::DOM_VK_END
+eNavigationDirection_First,  // nsIDOMKeyEvent::DOM_VK_HOME
+eNavigationDirection_Start,  // nsIDOMKeyEvent::DOM_VK_LEFT
+eNavigationDirection_Before, // nsIDOMKeyEvent::DOM_VK_UP
+eNavigationDirection_End,    // nsIDOMKeyEvent::DOM_VK_RIGHT
+eNavigationDirection_After   // nsIDOMKeyEvent::DOM_VK_DOWN
+},
+{
+eNavigationDirection_Last,   // nsIDOMKeyEvent::DOM_VK_END
+eNavigationDirection_First,  // nsIDOMKeyEvent::DOM_VK_HOME
+eNavigationDirection_End,    // nsIDOMKeyEvent::DOM_VK_LEFT
+eNavigationDirection_Before, // nsIDOMKeyEvent::DOM_VK_UP
+eNavigationDirection_Start,  // nsIDOMKeyEvent::DOM_VK_RIGHT
+eNavigationDirection_After   // nsIDOMKeyEvent::DOM_VK_DOWN
+}
+};
+nsXULPopupManager* nsXULPopupManager::sInstance = nullptr;
+nsIContent* nsMenuChainItem::Content()
+{
+return mFrame->GetContent();
+}
+void nsMenuChainItem::SetParent(nsMenuChainItem* aParent)
+{
+if (mParent) {
+NS_ASSERTION(mParent->mChild == this, "Unexpected - parent's child not set to this");
+mParent->mChild = nullptr;
+}
+mParent = aParent;
+if (mParent) {
+if (mParent->mChild)
+mParent->mChild->mParent = nullptr;
+mParent->mChild = this;
+}
+}
+void nsMenuChainItem::Detach(nsMenuChainItem** aRoot)
+{
+// If the item has a child, set the child's parent to this item's parent,
+// effectively removing the item from the chain. If the item has no child,
+// just set the parent to null.
+if (mChild) {
+NS_ASSERTION(this != *aRoot, "Unexpected - popup with child at end of chain");
+mChild->SetParent(mParent);
+}
+else {
+// An item without a child should be the first item in the chain, so set
+// the first item pointer, pointed to by aRoot, to the parent.
+NS_ASSERTION(this == *aRoot, "Unexpected - popup with no child not at end of chain");
+*aRoot = mParent;
+SetParent(nullptr);
+}
+}
+NS_IMPL_ISUPPORTS(nsXULPopupManager,
+nsIDOMEventListener,
+nsITimerCallback,
+nsIObserver)
+nsXULPopupManager::nsXULPopupManager() :
+mRangeOffset(0),
+mCachedMousePoint(0, 0),
+mCachedModifiers(0),
+mActiveMenuBar(nullptr),
+mPopups(nullptr),
+mNoHidePanels(nullptr),
+mTimerMenu(nullptr)
+{
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+if (obs) {
+obs->AddObserver(this, "xpcom-shutdown", false);
+}
+}
+nsXULPopupManager::~nsXULPopupManager()
+{
+NS_ASSERTION(!mPopups && !mNoHidePanels, "XUL popups still open");
+}
+nsresult
+nsXULPopupManager::Init()
+{
+sInstance = new nsXULPopupManager();
+NS_ENSURE_TRUE(sInstance, NS_ERROR_OUT_OF_MEMORY);
+NS_ADDREF(sInstance);
+return NS_OK;
+}
+void
+nsXULPopupManager::Shutdown()
+{
+NS_IF_RELEASE(sInstance);
+}
+NS_IMETHODIMP
+nsXULPopupManager::Observe(nsISupports *aSubject,
+const char *aTopic,
+const char16_t *aData)
+{
+if (!nsCRT::strcmp(aTopic, "xpcom-shutdown")) {
+if (mKeyListener) {
+mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keypress"), this, true);
+mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keydown"), this, true);
+mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keyup"), this, true);
+mKeyListener = nullptr;
+}
+mRangeParent = nullptr;
+// mOpeningPopup is cleared explicitly soon after using it.
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+if (obs) {
+obs->RemoveObserver(this, "xpcom-shutdown");
+}
+}
+return NS_OK;
+}
+nsXULPopupManager*
+nsXULPopupManager::GetInstance()
+{
+MOZ_ASSERT(sInstance);
+return sInstance;
+}
+bool
+nsXULPopupManager::Rollup(uint32_t aCount, const nsIntPoint* pos, nsIContent** aLastRolledUp)
+{
+bool consume = false;
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (item) {
+if (aLastRolledUp) {
+// we need to get the popup that will be closed last, so that
+// widget can keep track of it so it doesn't reopen if a mouse
+// down event is going to processed.
+// Keep going up the menu chain to get the first level menu. This will
+// be the one that closes up last. It's possible that this menu doesn't
+// end up closing because the popuphiding event was cancelled, but in
+// that case we don't need to deal with the menu reopening as it will
+// already still be open.
+nsMenuChainItem* first = item;
+while (first->GetParent())
+first = first->GetParent();
+*aLastRolledUp = first->Content();
+}
+consume = item->Frame()->ConsumeOutsideClicks();
+// If the click was over the anchor, always consume the click. This way,
+// clicking on a menu doesn't reopen the menu.
+if (!consume && pos) {
+nsCOMPtr<nsIContent> anchor = item->Frame()->GetAnchor();
+if (anchor && anchor->GetPrimaryFrame()) {
+// It's possible that some other element is above the anchor at the same
+// position, but the only thing that would happen is that the mouse
+// event will get consumed, so here only a quick coordinates check is
+// done rather than a slower complete check of what is at that location.
+if (anchor->GetPrimaryFrame()->GetScreenRect().Contains(*pos)) {
+consume = true;
+}
+}
+}
+// if a number of popups to close has been specified, determine the last
+// popup to close
+nsIContent* lastPopup = nullptr;
+if (aCount != UINT32_MAX) {
+nsMenuChainItem* last = item;
+while (--aCount && last->GetParent()) {
+last = last->GetParent();
+}
+if (last) {
+lastPopup = last->Content();
+}
+}
+HidePopup(item->Content(), true, true, false, true, lastPopup);
+}
+return consume;
+}
+////////////////////////////////////////////////////////////////////////
+bool nsXULPopupManager::ShouldRollupOnMouseWheelEvent()
+{
+// should rollup only for autocomplete widgets
+// XXXndeakin this should really be something the popup has more control over
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (!item)
+return false;
+nsIContent* content = item->Frame()->GetContent();
+if (!content)
+return false;
+if (content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::rolluponmousewheel,
+nsGkAtoms::_true, eCaseMatters))
+return true;
+if (content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::rolluponmousewheel,
+nsGkAtoms::_false, eCaseMatters))
+return false;
+nsAutoString value;
+content->GetAttr(kNameSpaceID_None, nsGkAtoms::type, value);
+return StringBeginsWith(value, NS_LITERAL_STRING("autocomplete"));
+}
+bool nsXULPopupManager::ShouldConsumeOnMouseWheelEvent()
+{
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (!item)
+return false;
+nsMenuPopupFrame* frame = item->Frame();
+if (frame->PopupType() != ePopupTypePanel)
+return true;
+nsIContent* content = frame->GetContent();
+return !(content && content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+nsGkAtoms::arrow, eCaseMatters));
+}
+// a menu should not roll up if activated by a mouse activate message (eg. X-mouse)
+bool nsXULPopupManager::ShouldRollupOnMouseActivate()
+{
+return false;
+}
+uint32_t
+nsXULPopupManager::GetSubmenuWidgetChain(nsTArray<nsIWidget*> *aWidgetChain)
+{
+// this method is used by the widget code to determine the list of popups
+// that are open. If a mouse click occurs outside one of these popups, the
+// panels will roll up. If the click is inside a popup, they will not roll up
+uint32_t count = 0, sameTypeCount = 0;
+NS_ASSERTION(aWidgetChain, "null parameter");
+nsMenuChainItem* item = GetTopVisibleMenu();
+while (item) {
+nsCOMPtr<nsIWidget> widget = item->Frame()->GetWidget();
+NS_ASSERTION(widget, "open popup has no widget");
+aWidgetChain->AppendElement(widget.get());
+// In the case when a menulist inside a panel is open, clicking in the
+// panel should still roll up the menu, so if a different type is found,
+// stop scanning.
+nsMenuChainItem* parent = item->GetParent();
+if (!sameTypeCount) {
+count++;
+if (!parent || item->Frame()->PopupType() != parent->Frame()->PopupType() ||
+item->IsContextMenu() != parent->IsContextMenu()) {
+sameTypeCount = count;
+}
+}
+item = parent;
+}
+return sameTypeCount;
+}
+nsIWidget*
+nsXULPopupManager::GetRollupWidget()
+{
+nsMenuChainItem* item = GetTopVisibleMenu();
+return item ? item->Frame()->GetWidget() : nullptr;
+}
+void
+nsXULPopupManager::AdjustPopupsOnWindowChange(nsPIDOMWindow* aWindow)
+{
+// When the parent window is moved, adjust any child popups. Dismissable
+// menus and panels are expected to roll up when a window is moved, so there
+// is no need to check these popups, only the noautohide popups.
+// The items are added to a list so that they can be adjusted bottom to top.
+nsTArray<nsMenuPopupFrame *> list;
+nsMenuChainItem* item = mNoHidePanels;
+while (item) {
+// only move popups that are within the same window and where auto
+// positioning has not been disabled
+nsMenuPopupFrame* frame = item->Frame();
+if (frame->GetAutoPosition()) {
+nsIContent* popup = frame->GetContent();
+if (popup) {
+nsIDocument* document = popup->GetCurrentDoc();
+if (document) {
+nsPIDOMWindow* window = document->GetWindow();
+if (window) {
+window = window->GetPrivateRoot();
+if (window == aWindow) {
+list.AppendElement(frame);
+}
+}
+}
+}
+}
+item = item->GetParent();
+}
+for (int32_t l = list.Length() - 1; l >= 0; l--) {
+list[l]->SetPopupPosition(nullptr, true, false);
+}
+}
+void nsXULPopupManager::AdjustPopupsOnWindowChange(nsIPresShell* aPresShell)
+{
+if (aPresShell->GetDocument()) {
+AdjustPopupsOnWindowChange(aPresShell->GetDocument()->GetWindow());
+}
+}
+static
+nsMenuPopupFrame* GetPopupToMoveOrResize(nsIFrame* aFrame)
+{
+nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(aFrame);
+if (!menuPopupFrame)
+return nullptr;
+// no point moving or resizing hidden popups
+if (menuPopupFrame->PopupState() != ePopupOpenAndVisible)
+return nullptr;
+nsIWidget* widget = menuPopupFrame->GetWidget();
+if (widget && !widget->IsVisible())
+return nullptr;
+return menuPopupFrame;
+}
+void
+nsXULPopupManager::PopupMoved(nsIFrame* aFrame, nsIntPoint aPnt)
+{
+nsMenuPopupFrame* menuPopupFrame = GetPopupToMoveOrResize(aFrame);
+if (!menuPopupFrame)
+return;
+nsView* view = menuPopupFrame->GetView();
+if (!view)
+return;
+// Don't do anything if the popup is already at the specified location. This
+// prevents recursive calls when a popup is positioned.
+nsIntRect curDevSize = view->CalcWidgetBounds(eWindowType_popup);
+nsIWidget* widget = menuPopupFrame->GetWidget();
+if (curDevSize.x == aPnt.x && curDevSize.y == aPnt.y &&
+(!widget || widget->GetClientOffset() == menuPopupFrame->GetLastClientOffset())) {
+return;
+}
+// Update the popup's position using SetPopupPosition if the popup is
+// anchored and at the parent level as these maintain their position
+// relative to the parent window. Otherwise, just update the popup to
+// the specified screen coordinates.
+if (menuPopupFrame->IsAnchored() &&
+menuPopupFrame->PopupLevel() == ePopupLevelParent) {
+menuPopupFrame->SetPopupPosition(nullptr, true, false);
+}
+else {
+nsPresContext* presContext = menuPopupFrame->PresContext();
+aPnt.x = presContext->DevPixelsToIntCSSPixels(aPnt.x);
+aPnt.y = presContext->DevPixelsToIntCSSPixels(aPnt.y);
+menuPopupFrame->MoveTo(aPnt.x, aPnt.y, false);
+}
+}
+void
+nsXULPopupManager::PopupResized(nsIFrame* aFrame, nsIntSize aSize)
+{
+nsMenuPopupFrame* menuPopupFrame = GetPopupToMoveOrResize(aFrame);
+if (!menuPopupFrame)
+return;
+nsView* view = menuPopupFrame->GetView();
+if (!view)
+return;
+nsIntRect curDevSize = view->CalcWidgetBounds(eWindowType_popup);
+// If the size is what we think it is, we have nothing to do.
+if (curDevSize.width == aSize.width && curDevSize.height == aSize.height)
+return;
+// The size is different. Convert the actual size to css pixels and store it
+// as 'width' and 'height' attributes on the popup.
+nsPresContext* presContext = menuPopupFrame->PresContext();
+nsIntSize newCSS(presContext->DevPixelsToIntCSSPixels(aSize.width),
+presContext->DevPixelsToIntCSSPixels(aSize.height));
+nsIContent* popup = menuPopupFrame->GetContent();
+nsAutoString width, height;
+width.AppendInt(newCSS.width);
+height.AppendInt(newCSS.height);
+popup->SetAttr(kNameSpaceID_None, nsGkAtoms::width, width, false);
+popup->SetAttr(kNameSpaceID_None, nsGkAtoms::height, height, true);
+}
+nsMenuPopupFrame*
+nsXULPopupManager::GetPopupFrameForContent(nsIContent* aContent, bool aShouldFlush)
+{
+if (aShouldFlush) {
+nsIDocument *document = aContent->GetCurrentDoc();
+if (document) {
+nsCOMPtr<nsIPresShell> presShell = document->GetShell();
+if (presShell)
+presShell->FlushPendingNotifications(Flush_Layout);
+}
+}
+return do_QueryFrame(aContent->GetPrimaryFrame());
+}
+nsMenuChainItem*
+nsXULPopupManager::GetTopVisibleMenu()
+{
+nsMenuChainItem* item = mPopups;
+while (item && item->Frame()->PopupState() == ePopupInvisible)
+item = item->GetParent();
+return item;
+}
+void
+nsXULPopupManager::GetMouseLocation(nsIDOMNode** aNode, int32_t* aOffset)
+{
+*aNode = mRangeParent;
+NS_IF_ADDREF(*aNode);
+*aOffset = mRangeOffset;
+}
+void
+nsXULPopupManager::InitTriggerEvent(nsIDOMEvent* aEvent, nsIContent* aPopup,
+nsIContent** aTriggerContent)
+{
+mCachedMousePoint = nsIntPoint(0, 0);
+if (aTriggerContent) {
+*aTriggerContent = nullptr;
+if (aEvent) {
+// get the trigger content from the event
+nsCOMPtr<nsIContent> target = do_QueryInterface(
+aEvent->InternalDOMEvent()->GetTarget());
+target.forget(aTriggerContent);
+}
+}
+mCachedModifiers = 0;
+nsCOMPtr<nsIDOMUIEvent> uiEvent = do_QueryInterface(aEvent);
+if (uiEvent) {
+uiEvent->GetRangeParent(getter_AddRefs(mRangeParent));
+uiEvent->GetRangeOffset(&mRangeOffset);
+// get the event coordinates relative to the root frame of the document
+// containing the popup.
+NS_ASSERTION(aPopup, "Expected a popup node");
+WidgetEvent* event = aEvent->GetInternalNSEvent();
+if (event) {
+WidgetInputEvent* inputEvent = event->AsInputEvent();
+if (inputEvent) {
+mCachedModifiers = inputEvent->modifiers;
+}
+nsIDocument* doc = aPopup->GetCurrentDoc();
+if (doc) {
+nsIPresShell* presShell = doc->GetShell();
+nsPresContext* presContext;
+if (presShell && (presContext = presShell->GetPresContext())) {
+nsPresContext* rootDocPresContext =
+presContext->GetRootPresContext();
+if (!rootDocPresContext)
+return;
+nsIFrame* rootDocumentRootFrame = rootDocPresContext->
+PresShell()->FrameManager()->GetRootFrame();
+if ((event->eventStructType == NS_MOUSE_EVENT ||
+event->eventStructType == NS_MOUSE_SCROLL_EVENT ||
+event->eventStructType == NS_WHEEL_EVENT) &&
+!event->AsGUIEvent()->widget) {
+// no widget, so just use the client point if available
+nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
+nsIntPoint clientPt;
+mouseEvent->GetClientX(&clientPt.x);
+mouseEvent->GetClientY(&clientPt.y);
+// XXX this doesn't handle IFRAMEs in transforms
+nsPoint thisDocToRootDocOffset = presShell->FrameManager()->
+GetRootFrame()->GetOffsetToCrossDoc(rootDocumentRootFrame);
+// convert to device pixels
+mCachedMousePoint.x = presContext->AppUnitsToDevPixels(
+nsPresContext::CSSPixelsToAppUnits(clientPt.x) + thisDocToRootDocOffset.x);
+mCachedMousePoint.y = presContext->AppUnitsToDevPixels(
+nsPresContext::CSSPixelsToAppUnits(clientPt.y) + thisDocToRootDocOffset.y);
+}
+else if (rootDocumentRootFrame) {
+nsPoint pnt =
+nsLayoutUtils::GetEventCoordinatesRelativeTo(event, rootDocumentRootFrame);
+mCachedMousePoint = nsIntPoint(rootDocPresContext->AppUnitsToDevPixels(pnt.x),
+rootDocPresContext->AppUnitsToDevPixels(pnt.y));
+}
+}
+}
+}
+}
+else {
+mRangeParent = nullptr;
+mRangeOffset = 0;
+}
+}
+void
+nsXULPopupManager::SetActiveMenuBar(nsMenuBarFrame* aMenuBar, bool aActivate)
+{
+if (aActivate)
+mActiveMenuBar = aMenuBar;
+else if (mActiveMenuBar == aMenuBar)
+mActiveMenuBar = nullptr;
+UpdateKeyboardListeners();
+}
+void
+nsXULPopupManager::ShowMenu(nsIContent *aMenu,
+bool aSelectFirstItem,
+bool aAsynchronous)
+{
+// generate any template content first. Otherwise, the menupopup may not
+// have been created yet.
+if (aMenu) {
+nsIContent* element = aMenu;
+do {
+nsCOMPtr<nsIDOMXULElement> xulelem = do_QueryInterface(element);
+if (xulelem) {
+nsCOMPtr<nsIXULTemplateBuilder> builder;
+xulelem->GetBuilder(getter_AddRefs(builder));
+if (builder) {
+builder->CreateContents(aMenu, true);
+break;
+}
+}
+element = element->GetParent();
+} while (element);
+}
+nsMenuFrame* menuFrame = do_QueryFrame(aMenu->GetPrimaryFrame());
+if (!menuFrame || !menuFrame->IsMenu())
+return;
+nsMenuPopupFrame* popupFrame =  menuFrame->GetPopup();
+if (!popupFrame || !MayShowPopup(popupFrame))
+return;
+// inherit whether or not we're a context menu from the parent
+bool parentIsContextMenu = false;
+bool onMenuBar = false;
+bool onmenu = menuFrame->IsOnMenu();
+nsMenuParent* parent = menuFrame->GetMenuParent();
+if (parent && onmenu) {
+parentIsContextMenu = parent->IsContextMenu();
+onMenuBar = parent->IsMenuBar();
+}
+nsAutoString position;
+if (onMenuBar || !onmenu)
+position.AssignLiteral("after_start");
+else
+position.AssignLiteral("end_before");
+// there is no trigger event for menus
+InitTriggerEvent(nullptr, nullptr, nullptr);
+popupFrame->InitializePopup(menuFrame->GetAnchor(), nullptr, position, 0, 0, true);
+if (aAsynchronous) {
+nsCOMPtr<nsIRunnable> event =
+new nsXULPopupShowingEvent(popupFrame->GetContent(),
+parentIsContextMenu, aSelectFirstItem);
+NS_DispatchToCurrentThread(event);
+}
+else {
+nsCOMPtr<nsIContent> popupContent = popupFrame->GetContent();
+FirePopupShowingEvent(popupContent, parentIsContextMenu, aSelectFirstItem);
+}
+}
+void
+nsXULPopupManager::ShowPopup(nsIContent* aPopup,
+nsIContent* aAnchorContent,
+const nsAString& aPosition,
+int32_t aXPos, int32_t aYPos,
+bool aIsContextMenu,
+bool aAttributesOverride,
+bool aSelectFirstItem,
+nsIDOMEvent* aTriggerEvent)
+{
+nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
+if (!popupFrame || !MayShowPopup(popupFrame))
+return;
+nsCOMPtr<nsIContent> triggerContent;
+InitTriggerEvent(aTriggerEvent, aPopup, getter_AddRefs(triggerContent));
+popupFrame->InitializePopup(aAnchorContent, triggerContent, aPosition,
+aXPos, aYPos, aAttributesOverride);
+FirePopupShowingEvent(aPopup, aIsContextMenu, aSelectFirstItem);
+}
+void
+nsXULPopupManager::ShowPopupAtScreen(nsIContent* aPopup,
+int32_t aXPos, int32_t aYPos,
+bool aIsContextMenu,
+nsIDOMEvent* aTriggerEvent)
+{
+nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
+if (!popupFrame || !MayShowPopup(popupFrame))
+return;
+nsCOMPtr<nsIContent> triggerContent;
+InitTriggerEvent(aTriggerEvent, aPopup, getter_AddRefs(triggerContent));
+popupFrame->InitializePopupAtScreen(triggerContent, aXPos, aYPos, aIsContextMenu);
+FirePopupShowingEvent(aPopup, aIsContextMenu, false);
+}
+void
+nsXULPopupManager::ShowTooltipAtScreen(nsIContent* aPopup,
+nsIContent* aTriggerContent,
+int32_t aXPos, int32_t aYPos)
+{
+nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
+if (!popupFrame || !MayShowPopup(popupFrame))
+return;
+InitTriggerEvent(nullptr, nullptr, nullptr);
+nsPresContext* pc = popupFrame->PresContext();
+mCachedMousePoint = nsIntPoint(pc->CSSPixelsToDevPixels(aXPos),
+pc->CSSPixelsToDevPixels(aYPos));
+// coordinates are relative to the root widget
+nsPresContext* rootPresContext = pc->GetRootPresContext();
+if (rootPresContext) {
+nsIWidget *rootWidget = rootPresContext->GetRootWidget();
+if (rootWidget) {
+mCachedMousePoint -= rootWidget->WidgetToScreenOffset();
+}
+}
+popupFrame->InitializePopupAtScreen(aTriggerContent, aXPos, aYPos, false);
+FirePopupShowingEvent(aPopup, false, false);
+}
+void
+nsXULPopupManager::ShowPopupWithAnchorAlign(nsIContent* aPopup,
+nsIContent* aAnchorContent,
+nsAString& aAnchor,
+nsAString& aAlign,
+int32_t aXPos, int32_t aYPos,
+bool aIsContextMenu)
+{
+nsMenuPopupFrame* popupFrame = GetPopupFrameForContent(aPopup, true);
+if (!popupFrame || !MayShowPopup(popupFrame))
+return;
+InitTriggerEvent(nullptr, nullptr, nullptr);
+popupFrame->InitializePopupWithAnchorAlign(aAnchorContent, aAnchor,
+aAlign, aXPos, aYPos);
+FirePopupShowingEvent(aPopup, aIsContextMenu, false);
+}
+static void
+CheckCaretDrawingState() {
+// There is 1 caret per document, we need to find the focused
+// document and erase its caret.
+nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+if (fm) {
+nsCOMPtr<nsIDOMWindow> window;
+fm->GetFocusedWindow(getter_AddRefs(window));
+if (!window)
+return;
+nsCOMPtr<nsIDOMDocument> domDoc;
+nsCOMPtr<nsIDocument> focusedDoc;
+window->GetDocument(getter_AddRefs(domDoc));
+focusedDoc = do_QueryInterface(domDoc);
+if (!focusedDoc)
+return;
+nsIPresShell* presShell = focusedDoc->GetShell();
+if (!presShell)
+return;
+nsRefPtr<nsCaret> caret = presShell->GetCaret();
+if (!caret)
+return;
+caret->CheckCaretDrawingState();
+}
+}
+void
+nsXULPopupManager::ShowPopupCallback(nsIContent* aPopup,
+nsMenuPopupFrame* aPopupFrame,
+bool aIsContextMenu,
+bool aSelectFirstItem)
+{
+nsPopupType popupType = aPopupFrame->PopupType();
+bool ismenu = (popupType == ePopupTypeMenu);
+nsMenuChainItem* item =
+new nsMenuChainItem(aPopupFrame, aIsContextMenu, popupType);
+if (!item)
+return;
+// install keyboard event listeners for navigating menus. For panels, the
+// escape key may be used to close the panel. However, the ignorekeys
+// attribute may be used to disable adding these event listeners for popups
+// that want to handle their own keyboard events.
+if (aPopup->AttrValueIs(kNameSpaceID_None, nsGkAtoms::ignorekeys,
+nsGkAtoms::_true, eCaseMatters))
+item->SetIgnoreKeys(true);
+if (ismenu) {
+// if the menu is on a menubar, use the menubar's listener instead
+nsMenuFrame* menuFrame = do_QueryFrame(aPopupFrame->GetParent());
+if (menuFrame) {
+item->SetOnMenuBar(menuFrame->IsOnMenuBar());
+}
+}
+// use a weak frame as the popup will set an open attribute if it is a menu
+nsWeakFrame weakFrame(aPopupFrame);
+aPopupFrame->ShowPopup(aIsContextMenu, aSelectFirstItem);
+ENSURE_TRUE(weakFrame.IsAlive());
+// popups normally hide when an outside click occurs. Panels may use
+// the noautohide attribute to disable this behaviour. It is expected
+// that the application will hide these popups manually. The tooltip
+// listener will handle closing the tooltip also.
+if (aPopupFrame->IsNoAutoHide() || popupType == ePopupTypeTooltip) {
+item->SetParent(mNoHidePanels);
+mNoHidePanels = item;
+}
+else {
+nsIContent* oldmenu = nullptr;
+if (mPopups)
+oldmenu = mPopups->Content();
+item->SetParent(mPopups);
+mPopups = item;
+SetCaptureState(oldmenu);
+}
+if (aSelectFirstItem) {
+nsMenuFrame* next = GetNextMenuItem(aPopupFrame, nullptr, true);
+aPopupFrame->SetCurrentMenuItem(next);
+}
+if (ismenu)
+UpdateMenuItems(aPopup);
+// Caret visibility may have been affected, ensure that
+// the caret isn't now drawn when it shouldn't be.
+CheckCaretDrawingState();
+}
+void
+nsXULPopupManager::HidePopup(nsIContent* aPopup,
+bool aHideChain,
+bool aDeselectMenu,
+bool aAsynchronous,
+bool aIsRollup,
+nsIContent* aLastPopup)
+{
+// if the popup is on the nohide panels list, remove it but don't close any
+// other panels
+nsMenuPopupFrame* popupFrame = nullptr;
+bool foundPanel = false;
+nsMenuChainItem* item = mNoHidePanels;
+while (item) {
+if (item->Content() == aPopup) {
+foundPanel = true;
+popupFrame = item->Frame();
+break;
+}
+item = item->GetParent();
+}
+// when removing a menu, all of the child popups must be closed
+nsMenuChainItem* foundMenu = nullptr;
+item = mPopups;
+while (item) {
+if (item->Content() == aPopup) {
+foundMenu = item;
+break;
+}
+item = item->GetParent();
+}
+nsPopupType type = ePopupTypePanel;
+bool deselectMenu = false;
+nsCOMPtr<nsIContent> popupToHide, nextPopup, lastPopup;
+if (foundMenu) {
+// at this point, foundMenu will be set to the found item in the list. If
+// foundMenu is the topmost menu, the one to remove, then there are no other
+// popups to hide. If foundMenu is not the topmost menu, then there may be
+// open submenus below it. In this case, we need to make sure that those
+// submenus are closed up first. To do this, we scan up the menu list to
+// find the topmost popup with only menus between it and foundMenu and
+// close that menu first. In synchronous mode, the FirePopupHidingEvent
+// method will be called which in turn calls HidePopupCallback to close up
+// the next popup in the chain. These two methods will be called in
+// sequence recursively to close up all the necessary popups. In
+// asynchronous mode, a similar process occurs except that the
+// FirePopupHidingEvent method is called asynchronously. In either case,
+// nextPopup is set to the content node of the next popup to close, and
+// lastPopup is set to the last popup in the chain to close, which will be
+// aPopup, or null to close up all menus.
+nsMenuChainItem* topMenu = foundMenu;
+// Use IsMenu to ensure that foundMenu is a menu and scan down the child
+// list until a non-menu is found. If foundMenu isn't a menu at all, don't
+// scan and just close up this menu.
+if (foundMenu->IsMenu()) {
+item = topMenu->GetChild();
+while (item && item->IsMenu()) {
+topMenu = item;
+item = item->GetChild();
+}
+}
+deselectMenu = aDeselectMenu;
+popupToHide = topMenu->Content();
+popupFrame = topMenu->Frame();
+type = popupFrame->PopupType();
+nsMenuChainItem* parent = topMenu->GetParent();
+// close up another popup if there is one, and we are either hiding the
+// entire chain or the item to hide isn't the topmost popup.
+if (parent && (aHideChain || topMenu != foundMenu))
+nextPopup = parent->Content();
+lastPopup = aLastPopup ? aLastPopup : (aHideChain ? nullptr : aPopup);
+}
+else if (foundPanel) {
+popupToHide = aPopup;
+}
+if (popupFrame) {
+nsPopupState state = popupFrame->PopupState();
+// if the popup is already being hidden, don't attempt to hide it again
+if (state == ePopupHiding)
+return;
+// change the popup state to hiding. Don't set the hiding state if the
+// popup is invisible, otherwise nsMenuPopupFrame::HidePopup will
+// run again. In the invisible state, we just want the events to fire.
+if (state != ePopupInvisible)
+popupFrame->SetPopupState(ePopupHiding);
+// for menus, popupToHide is always the frontmost item in the list to hide.
+if (aAsynchronous) {
+nsCOMPtr<nsIRunnable> event =
+new nsXULPopupHidingEvent(popupToHide, nextPopup, lastPopup,
+type, deselectMenu, aIsRollup);
+NS_DispatchToCurrentThread(event);
+}
+else {
+FirePopupHidingEvent(popupToHide, nextPopup, lastPopup,
+popupFrame->PresContext(), type, deselectMenu, aIsRollup);
+}
+}
+}
+// This is used to hide the popup after a transition finishes.
+class TransitionEnder : public nsIDOMEventListener
+{
+public:
+nsCOMPtr<nsIContent> mContent;
+bool mDeselectMenu;
+NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+NS_DECL_CYCLE_COLLECTION_CLASS(TransitionEnder)
+TransitionEnder(nsIContent* aContent, bool aDeselectMenu)
+: mContent(aContent), mDeselectMenu(aDeselectMenu)
+{
+}
+virtual ~TransitionEnder() { }
+NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent) MOZ_OVERRIDE
+{
+mContent->RemoveSystemEventListener(NS_LITERAL_STRING("transitionend"), this, false);
+nsMenuPopupFrame* popupFrame = do_QueryFrame(mContent->GetPrimaryFrame());
+// Now hide the popup. There could be other properties transitioning, but
+// we'll assume they all end at the same time and just hide the popup upon
+// the first one ending.
+nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+if (pm && popupFrame) {
+pm->HidePopupCallback(mContent, popupFrame, nullptr, nullptr,
+popupFrame->PopupType(), mDeselectMenu);
+}
+return NS_OK;
+}
+};
+NS_IMPL_CYCLE_COLLECTING_ADDREF(TransitionEnder)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(TransitionEnder)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TransitionEnder)
+NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTION(TransitionEnder, mContent);
+void
+nsXULPopupManager::HidePopupCallback(nsIContent* aPopup,
+nsMenuPopupFrame* aPopupFrame,
+nsIContent* aNextPopup,
+nsIContent* aLastPopup,
+nsPopupType aPopupType,
+bool aDeselectMenu)
+{
+if (mCloseTimer && mTimerMenu == aPopupFrame) {
+mCloseTimer->Cancel();
+mCloseTimer = nullptr;
+mTimerMenu = nullptr;
+}
+// The popup to hide is aPopup. Search the list again to find the item that
+// corresponds to the popup to hide aPopup. This is done because it's
+// possible someone added another item (attempted to open another popup)
+// or removed a popup frame during the event processing so the item isn't at
+// the front anymore.
+nsMenuChainItem* item = mNoHidePanels;
+while (item) {
+if (item->Content() == aPopup) {
+item->Detach(&mNoHidePanels);
+break;
+}
+item = item->GetParent();
+}
+if (!item) {
+item = mPopups;
+while (item) {
+if (item->Content() == aPopup) {
+item->Detach(&mPopups);
+SetCaptureState(aPopup);
+break;
+}
+item = item->GetParent();
+}
+}
+delete item;
+nsWeakFrame weakFrame(aPopupFrame);
+aPopupFrame->HidePopup(aDeselectMenu, ePopupClosed);
+ENSURE_TRUE(weakFrame.IsAlive());
+// send the popuphidden event synchronously. This event has no default
+// behaviour.
+nsEventStatus status = nsEventStatus_eIgnore;
+WidgetMouseEvent event(true, NS_XUL_POPUP_HIDDEN, nullptr,
+WidgetMouseEvent::eReal);
+EventDispatcher::Dispatch(aPopup, aPopupFrame->PresContext(),
+&event, nullptr, &status);
+ENSURE_TRUE(weakFrame.IsAlive());
+// if there are more popups to close, look for the next one
+if (aNextPopup && aPopup != aLastPopup) {
+nsMenuChainItem* foundMenu = nullptr;
+nsMenuChainItem* item = mPopups;
+while (item) {
+if (item->Content() == aNextPopup) {
+foundMenu = item;
+break;
+}
+item = item->GetParent();
+}
+// continue hiding the chain of popups until the last popup aLastPopup
+// is reached, or until a popup of a different type is reached. This
+// last check is needed so that a menulist inside a non-menu panel only
+// closes the menu and not the panel as well.
+if (foundMenu &&
+(aLastPopup || aPopupType == foundMenu->PopupType())) {
+nsCOMPtr<nsIContent> popupToHide = item->Content();
+nsMenuChainItem* parent = item->GetParent();
+nsCOMPtr<nsIContent> nextPopup;
+if (parent && popupToHide != aLastPopup)
+nextPopup = parent->Content();
+nsMenuPopupFrame* popupFrame = item->Frame();
+nsPopupState state = popupFrame->PopupState();
+if (state == ePopupHiding)
+return;
+if (state != ePopupInvisible)
+popupFrame->SetPopupState(ePopupHiding);
+FirePopupHidingEvent(popupToHide, nextPopup, aLastPopup,
+popupFrame->PresContext(),
+foundMenu->PopupType(), aDeselectMenu, false);
+}
+}
+}
+void
+nsXULPopupManager::HidePopup(nsIFrame* aFrame)
+{
+nsMenuPopupFrame* popup = do_QueryFrame(aFrame);
+if (popup)
+HidePopup(aFrame->GetContent(), false, true, false, false);
+}
+void
+nsXULPopupManager::HidePopupAfterDelay(nsMenuPopupFrame* aPopup)
+{
+// Don't close up immediately.
+// Kick off a close timer.
+KillMenuTimer();
+int32_t menuDelay =
+LookAndFeel::GetInt(LookAndFeel::eIntID_SubmenuDelay, 300); // ms
+// Kick off the timer.
+mCloseTimer = do_CreateInstance("@mozilla.org/timer;1");
+mCloseTimer->InitWithCallback(this, menuDelay, nsITimer::TYPE_ONE_SHOT);
+// the popup will call PopupDestroyed if it is destroyed, which checks if it
+// is set to mTimerMenu, so it should be safe to keep a reference to it
+mTimerMenu = aPopup;
+}
+void
+nsXULPopupManager::HidePopupsInList(const nsTArray<nsMenuPopupFrame *> &aFrames,
+bool aDeselectMenu)
+{
+// Create a weak frame list. This is done in a separate array with the
+// right capacity predetermined, otherwise the array would get resized and
+// move the weak frame pointers around.
+nsTArray<nsWeakFrame> weakPopups(aFrames.Length());
+uint32_t f;
+for (f = 0; f < aFrames.Length(); f++) {
+nsWeakFrame* wframe = weakPopups.AppendElement();
+if (wframe)
+*wframe = aFrames[f];
+}
+for (f = 0; f < weakPopups.Length(); f++) {
+// check to ensure that the frame is still alive before hiding it.
+if (weakPopups[f].IsAlive()) {
+nsMenuPopupFrame* frame =
+static_cast<nsMenuPopupFrame *>(weakPopups[f].GetFrame());
+frame->HidePopup(true, ePopupInvisible);
+}
+}
+SetCaptureState(nullptr);
+}
+bool
+nsXULPopupManager::IsChildOfDocShell(nsIDocument* aDoc, nsIDocShellTreeItem* aExpected)
+{
+nsCOMPtr<nsIDocShellTreeItem> docShellItem(aDoc->GetDocShell());
+while(docShellItem) {
+if (docShellItem == aExpected)
+return true;
+nsCOMPtr<nsIDocShellTreeItem> parent;
+docShellItem->GetParent(getter_AddRefs(parent));
+docShellItem = parent;
+}
+return false;
+}
+void
+nsXULPopupManager::HidePopupsInDocShell(nsIDocShellTreeItem* aDocShellToHide)
+{
+nsTArray<nsMenuPopupFrame *> popupsToHide;
+// iterate to get the set of popup frames to hide
+nsMenuChainItem* item = mPopups;
+while (item) {
+nsMenuChainItem* parent = item->GetParent();
+if (item->Frame()->PopupState() != ePopupInvisible &&
+IsChildOfDocShell(item->Content()->OwnerDoc(), aDocShellToHide)) {
+nsMenuPopupFrame* frame = item->Frame();
+item->Detach(&mPopups);
+delete item;
+popupsToHide.AppendElement(frame);
+}
+item = parent;
+}
+// now look for panels to hide
+item = mNoHidePanels;
+while (item) {
+nsMenuChainItem* parent = item->GetParent();
+if (item->Frame()->PopupState() != ePopupInvisible &&
+IsChildOfDocShell(item->Content()->OwnerDoc(), aDocShellToHide)) {
+nsMenuPopupFrame* frame = item->Frame();
+item->Detach(&mNoHidePanels);
+delete item;
+popupsToHide.AppendElement(frame);
+}
+item = parent;
+}
+HidePopupsInList(popupsToHide, true);
+}
+void
+nsXULPopupManager::ExecuteMenu(nsIContent* aMenu, nsXULMenuCommandEvent* aEvent)
+{
+CloseMenuMode cmm = CloseMenuMode_Auto;
+static nsIContent::AttrValuesArray strings[] =
+{&nsGkAtoms::none, &nsGkAtoms::single, nullptr};
+switch (aMenu->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::closemenu,
+strings, eCaseMatters)) {
+case 0:
+cmm = CloseMenuMode_None;
+break;
+case 1:
+cmm = CloseMenuMode_Single;
+break;
+default:
+break;
+}
+// When a menuitem is selected to be executed, first hide all the open
+// popups, but don't remove them yet. This is needed when a menu command
+// opens a modal dialog. The views associated with the popups needed to be
+// hidden and the accesibility events fired before the command executes, but
+// the popuphiding/popuphidden events are fired afterwards.
+nsTArray<nsMenuPopupFrame *> popupsToHide;
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (cmm != CloseMenuMode_None) {
+while (item) {
+// if it isn't a <menupopup>, don't close it automatically
+if (!item->IsMenu())
+break;
+nsMenuChainItem* next = item->GetParent();
+popupsToHide.AppendElement(item->Frame());
+if (cmm == CloseMenuMode_Single) // only close one level of menu
+break;
+item = next;
+}
+// Now hide the popups. If the closemenu mode is auto, deselect the menu,
+// otherwise only one popup is closing, so keep the parent menu selected.
+HidePopupsInList(popupsToHide, cmm == CloseMenuMode_Auto);
+}
+aEvent->SetCloseMenuMode(cmm);
+nsCOMPtr<nsIRunnable> event = aEvent;
+NS_DispatchToCurrentThread(event);
+}
+void
+nsXULPopupManager::FirePopupShowingEvent(nsIContent* aPopup,
+bool aIsContextMenu,
+bool aSelectFirstItem)
+{
+nsCOMPtr<nsIContent> popup = aPopup; // keep a strong reference to the popup
+nsMenuPopupFrame* popupFrame = do_QueryFrame(aPopup->GetPrimaryFrame());
+if (!popupFrame)
+return;
+nsPresContext *presContext = popupFrame->PresContext();
+nsCOMPtr<nsIPresShell> presShell = presContext->PresShell();
+nsPopupType popupType = popupFrame->PopupType();
+// generate the child frames if they have not already been generated
+if (!popupFrame->HasGeneratedChildren()) {
+popupFrame->SetGeneratedChildren();
+presShell->FrameConstructor()->GenerateChildFrames(popupFrame);
+}
+// get the frame again
+nsIFrame* frame = aPopup->GetPrimaryFrame();
+if (!frame)
+return;
+presShell->FrameNeedsReflow(frame, nsIPresShell::eTreeChange,
+NS_FRAME_HAS_DIRTY_CHILDREN);
+// cache the popup so that document.popupNode can retrieve the trigger node
+// during the popupshowing event. It will be cleared below after the event
+// has fired.
+mOpeningPopup = aPopup;
+nsEventStatus status = nsEventStatus_eIgnore;
+WidgetMouseEvent event(true, NS_XUL_POPUP_SHOWING, nullptr,
+WidgetMouseEvent::eReal);
+// coordinates are relative to the root widget
+nsPresContext* rootPresContext =
+presShell->GetPresContext()->GetRootPresContext();
+if (rootPresContext) {
+rootPresContext->PresShell()->GetViewManager()->
+GetRootWidget(getter_AddRefs(event.widget));
+}
+else {
+event.widget = nullptr;
+}
+event.refPoint = LayoutDeviceIntPoint::FromUntyped(mCachedMousePoint);
+event.modifiers = mCachedModifiers;
+EventDispatcher::Dispatch(popup, presContext, &event, nullptr, &status);
+mCachedMousePoint = nsIntPoint(0, 0);
+mOpeningPopup = nullptr;
+mCachedModifiers = 0;
+// if a panel, blur whatever has focus so that the panel can take the focus.
+// This is done after the popupshowing event in case that event is cancelled.
+// Using noautofocus="true" will disable this behaviour, which is needed for
+// the autocomplete widget as it manages focus itself.
+if (popupType == ePopupTypePanel &&
+!popup->AttrValueIs(kNameSpaceID_None, nsGkAtoms::noautofocus,
+nsGkAtoms::_true, eCaseMatters)) {
+nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+if (fm) {
+nsIDocument* doc = popup->GetCurrentDoc();
+// Only remove the focus if the currently focused item is ouside the
+// popup. It isn't a big deal if the current focus is in a child popup
+// inside the popup as that shouldn't be visible. This check ensures that
+// a node inside the popup that is focused during a popupshowing event
+// remains focused.
+nsCOMPtr<nsIDOMElement> currentFocusElement;
+fm->GetFocusedElement(getter_AddRefs(currentFocusElement));
+nsCOMPtr<nsIContent> currentFocus = do_QueryInterface(currentFocusElement);
+if (doc && currentFocus &&
+!nsContentUtils::ContentIsCrossDocDescendantOf(currentFocus, popup)) {
+fm->ClearFocus(doc->GetWindow());
+}
+}
+}
+// clear these as they are no longer valid
+mRangeParent = nullptr;
+mRangeOffset = 0;
+// get the frame again in case it went away
+popupFrame = do_QueryFrame(aPopup->GetPrimaryFrame());
+if (popupFrame) {
+// if the event was cancelled, don't open the popup, reset its state back
+// to closed and clear its trigger content.
+if (status == nsEventStatus_eConsumeNoDefault) {
+popupFrame->SetPopupState(ePopupClosed);
+popupFrame->ClearTriggerContent();
+}
+else {
+ShowPopupCallback(aPopup, popupFrame, aIsContextMenu, aSelectFirstItem);
+}
+}
+}
+void
+nsXULPopupManager::FirePopupHidingEvent(nsIContent* aPopup,
+nsIContent* aNextPopup,
+nsIContent* aLastPopup,
+nsPresContext *aPresContext,
+nsPopupType aPopupType,
+bool aDeselectMenu,
+bool aIsRollup)
+{
+nsCOMPtr<nsIPresShell> presShell = aPresContext->PresShell();
+nsEventStatus status = nsEventStatus_eIgnore;
+WidgetMouseEvent event(true, NS_XUL_POPUP_HIDING, nullptr,
+WidgetMouseEvent::eReal);
+EventDispatcher::Dispatch(aPopup, aPresContext, &event, nullptr, &status);
+// when a panel is closed, blur whatever has focus inside the popup
+if (aPopupType == ePopupTypePanel &&
+!aPopup->AttrValueIs(kNameSpaceID_None, nsGkAtoms::noautofocus,
+nsGkAtoms::_true, eCaseMatters)) {
+nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+if (fm) {
+nsIDocument* doc = aPopup->GetCurrentDoc();
+// Remove the focus from the focused node only if it is inside the popup.
+nsCOMPtr<nsIDOMElement> currentFocusElement;
+fm->GetFocusedElement(getter_AddRefs(currentFocusElement));
+nsCOMPtr<nsIContent> currentFocus = do_QueryInterface(currentFocusElement);
+if (doc && currentFocus &&
+nsContentUtils::ContentIsCrossDocDescendantOf(currentFocus, aPopup)) {
+fm->ClearFocus(doc->GetWindow());
+}
+}
+}
+// get frame again in case it went away
+nsMenuPopupFrame* popupFrame = do_QueryFrame(aPopup->GetPrimaryFrame());
+if (popupFrame) {
+// if the event was cancelled, don't hide the popup, and reset its
+// state back to open. Only popups in chrome shells can prevent a popup
+// from hiding.
+if (status == nsEventStatus_eConsumeNoDefault &&
+!popupFrame->IsInContentShell()) {
+popupFrame->SetPopupState(ePopupOpenAndVisible);
+}
+else {
+// If the popup has an animate attribute and it is not set to false, assume
+// that it has a closing transition and wait for it to finish. The transition
+// may still occur either way, but the view will be hidden and you won't be
+// able to see it. If there is a next popup, indicating that mutliple popups
+// are rolling up, don't wait and hide the popup right away since the effect
+// would likely be undesirable. This also does a quick check to see if the
+// popup has a transition defined, and skips the wait if not. Transitions
+// are currently disabled on Linux due to rendering issues on certain
+// configurations.
+#ifndef MOZ_WIDGET_GTK
+if (!aNextPopup && aPopup->HasAttr(kNameSpaceID_None, nsGkAtoms::animate) &&
+popupFrame->StyleDisplay()->mTransitionPropertyCount > 0) {
+nsAutoString animate;
+aPopup->GetAttr(kNameSpaceID_None, nsGkAtoms::animate, animate);
+// If animate="false" then don't transition at all. If animate="cancel",
+// only show the transition if cancelling the popup or rolling up.
+// Otherwise, always show the transition.
+if (!animate.EqualsLiteral("false") &&
+(!animate.EqualsLiteral("cancel") || aIsRollup)) {
+nsCOMPtr<TransitionEnder> ender = new TransitionEnder(aPopup, aDeselectMenu);
+aPopup->AddSystemEventListener(NS_LITERAL_STRING("transitionend"),
+ender, false, false);
+return;
+}
+}
+#endif
+HidePopupCallback(aPopup, popupFrame, aNextPopup, aLastPopup,
+aPopupType, aDeselectMenu);
+}
+}
+}
+bool
+nsXULPopupManager::IsPopupOpen(nsIContent* aPopup)
+{
+// a popup is open if it is in the open list. The assertions ensure that the
+// frame is in the correct state. If the popup is in the hiding or invisible
+// state, it will still be in the open popup list until it is closed.
+nsMenuChainItem* item = mPopups;
+while (item) {
+if (item->Content() == aPopup) {
+NS_ASSERTION(item->Frame()->IsOpen() ||
+item->Frame()->PopupState() == ePopupHiding ||
+item->Frame()->PopupState() == ePopupInvisible,
+"popup in open list not actually open");
+return true;
+}
+item = item->GetParent();
+}
+item = mNoHidePanels;
+while (item) {
+if (item->Content() == aPopup) {
+NS_ASSERTION(item->Frame()->IsOpen() ||
+item->Frame()->PopupState() == ePopupHiding ||
+item->Frame()->PopupState() == ePopupInvisible,
+"popup in open list not actually open");
+return true;
+}
+item = item->GetParent();
+}
+return false;
+}
+bool
+nsXULPopupManager::IsPopupOpenForMenuParent(nsMenuParent* aMenuParent)
+{
+nsMenuChainItem* item = GetTopVisibleMenu();
+while (item) {
+nsMenuPopupFrame* popup = item->Frame();
+if (popup && popup->IsOpen()) {
+nsMenuFrame* menuFrame = do_QueryFrame(popup->GetParent());
+if (menuFrame && menuFrame->GetMenuParent() == aMenuParent) {
+return true;
+}
+}
+item = item->GetParent();
+}
+return false;
+}
+nsIFrame*
+nsXULPopupManager::GetTopPopup(nsPopupType aType)
+{
+if ((aType == ePopupTypePanel || aType == ePopupTypeTooltip) && mNoHidePanels)
+return mNoHidePanels->Frame();
+nsMenuChainItem* item = GetTopVisibleMenu();
+while (item) {
+if (item->PopupType() == aType || aType == ePopupTypeAny)
+return item->Frame();
+item = item->GetParent();
+}
+return nullptr;
+}
+void
+nsXULPopupManager::GetVisiblePopups(nsTArray<nsIFrame *>& aPopups)
+{
+aPopups.Clear();
+// Iterate over both lists of popups
+nsMenuChainItem* item = mPopups;
+for (int32_t list = 0; list < 2; list++) {
+while (item) {
+// Skip panels which are not open and visible as well as popups that
+// are transparent to mouse events.
+if (item->Frame()->PopupState() == ePopupOpenAndVisible &&
+!item->Frame()->IsMouseTransparent()) {
+aPopups.AppendElement(item->Frame());
+}
+item = item->GetParent();
+}
+item = mNoHidePanels;
+}
+}
+already_AddRefed<nsIDOMNode>
+nsXULPopupManager::GetLastTriggerNode(nsIDocument* aDocument, bool aIsTooltip)
+{
+if (!aDocument)
+return nullptr;
+nsCOMPtr<nsIDOMNode> node;
+// if mOpeningPopup is set, it means that a popupshowing event is being
+// fired. In this case, just use the cached node, as the popup is not yet in
+// the list of open popups.
+if (mOpeningPopup && mOpeningPopup->GetCurrentDoc() == aDocument &&
+aIsTooltip == (mOpeningPopup->Tag() == nsGkAtoms::tooltip)) {
+node = do_QueryInterface(nsMenuPopupFrame::GetTriggerContent(GetPopupFrameForContent(mOpeningPopup, false)));
+}
+else {
+nsMenuChainItem* item = aIsTooltip ? mNoHidePanels : mPopups;
+while (item) {
+// look for a popup of the same type and document.
+if ((item->PopupType() == ePopupTypeTooltip) == aIsTooltip &&
+item->Content()->GetCurrentDoc() == aDocument) {
+node = do_QueryInterface(nsMenuPopupFrame::GetTriggerContent(item->Frame()));
+if (node)
+break;
+}
+item = item->GetParent();
+}
+}
+return node.forget();
+}
+bool
+nsXULPopupManager::MayShowPopup(nsMenuPopupFrame* aPopup)
+{
+// if a popup's IsOpen method returns true, then the popup must always be in
+// the popup chain scanned in IsPopupOpen.
+NS_ASSERTION(!aPopup->IsOpen() || IsPopupOpen(aPopup->GetContent()),
+"popup frame state doesn't match XULPopupManager open state");
+nsPopupState state = aPopup->PopupState();
+// if the popup is not in the open popup chain, then it must have a state that
+// is either closed, in the process of being shown, or invisible.
+NS_ASSERTION(IsPopupOpen(aPopup->GetContent()) || state == ePopupClosed ||
+state == ePopupShowing || state == ePopupInvisible,
+"popup not in XULPopupManager open list is open");
+// don't show popups unless they are closed or invisible
+if (state != ePopupClosed && state != ePopupInvisible)
+return false;
+// Don't show popups that we already have in our popup chain
+if (IsPopupOpen(aPopup->GetContent())) {
+NS_WARNING("Refusing to show duplicate popup");
+return false;
+}
+// if the popup was just rolled up, don't reopen it
+nsCOMPtr<nsIWidget> widget = aPopup->GetWidget();
+if (widget && widget->GetLastRollup() == aPopup->GetContent())
+return false;
+nsCOMPtr<nsIDocShellTreeItem> dsti = aPopup->PresContext()->GetDocShell();
+nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(dsti);
+if (!baseWin)
+return false;
+// chrome shells can always open popups, but other types of shells can only
+// open popups when they are focused and visible
+if (dsti->ItemType() != nsIDocShellTreeItem::typeChrome) {
+// only allow popups in active windows
+nsCOMPtr<nsIDocShellTreeItem> root;
+dsti->GetRootTreeItem(getter_AddRefs(root));
+nsCOMPtr<nsIDOMWindow> rootWin = do_GetInterface(root);
+nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+if (!fm || !rootWin)
+return false;
+nsCOMPtr<nsIDOMWindow> activeWindow;
+fm->GetActiveWindow(getter_AddRefs(activeWindow));
+if (activeWindow != rootWin)
+return false;
+// only allow popups in visible frames
+bool visible;
+baseWin->GetVisibility(&visible);
+if (!visible)
+return false;
+}
+// platforms respond differently when an popup is opened in a minimized
+// window, so this is always disabled.
+nsCOMPtr<nsIWidget> mainWidget;
+baseWin->GetMainWidget(getter_AddRefs(mainWidget));
+if (mainWidget && mainWidget->SizeMode() == nsSizeMode_Minimized) {
+return false;
+}
+// cannot open a popup that is a submenu of a menupopup that isn't open.
+nsMenuFrame* menuFrame = do_QueryFrame(aPopup->GetParent());
+if (menuFrame) {
+nsMenuParent* parentPopup = menuFrame->GetMenuParent();
+if (parentPopup && !parentPopup->IsOpen())
+return false;
+}
+return true;
+}
+void
+nsXULPopupManager::PopupDestroyed(nsMenuPopupFrame* aPopup)
+{
+// when a popup frame is destroyed, just unhook it from the list of popups
+if (mTimerMenu == aPopup) {
+if (mCloseTimer) {
+mCloseTimer->Cancel();
+mCloseTimer = nullptr;
+}
+mTimerMenu = nullptr;
+}
+nsMenuChainItem* item = mNoHidePanels;
+while (item) {
+if (item->Frame() == aPopup) {
+item->Detach(&mNoHidePanels);
+delete item;
+break;
+}
+item = item->GetParent();
+}
+nsTArray<nsMenuPopupFrame *> popupsToHide;
+item = mPopups;
+while (item) {
+nsMenuPopupFrame* frame = item->Frame();
+if (frame == aPopup) {
+if (frame->PopupState() != ePopupInvisible) {
+// Iterate through any child menus and hide them as well, since the
+// parent is going away. We won't remove them from the list yet, just
+// hide them, as they will be removed from the list when this function
+// gets called for that child frame.
+nsMenuChainItem* child = item->GetChild();
+while (child) {
+// if the popup is a child frame of the menu that was destroyed, add
+// it to the list of popups to hide. Don't bother with the events
+// since the frames are going away. If the child menu is not a child
+// frame, for example, a context menu, use HidePopup instead, but call
+// it asynchronously since we are in the middle of frame destruction.
+nsMenuPopupFrame* childframe = child->Frame();
+if (nsLayoutUtils::IsProperAncestorFrame(frame, childframe)) {
+popupsToHide.AppendElement(childframe);
+}
+else {
+// HidePopup will take care of hiding any of its children, so
+// break out afterwards
+HidePopup(child->Content(), false, false, true, false);
+break;
+}
+child = child->GetChild();
+}
+}
+item->Detach(&mPopups);
+delete item;
+break;
+}
+item = item->GetParent();
+}
+HidePopupsInList(popupsToHide, false);
+}
+bool
+nsXULPopupManager::HasContextMenu(nsMenuPopupFrame* aPopup)
+{
+nsMenuChainItem* item = GetTopVisibleMenu();
+while (item && item->Frame() != aPopup) {
+if (item->IsContextMenu())
+return true;
+item = item->GetParent();
+}
+return false;
+}
+void
+nsXULPopupManager::SetCaptureState(nsIContent* aOldPopup)
+{
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (item && aOldPopup == item->Content())
+return;
+if (mWidget) {
+mWidget->CaptureRollupEvents(nullptr, false);
+mWidget = nullptr;
+}
+if (item) {
+nsMenuPopupFrame* popup = item->Frame();
+mWidget = popup->GetWidget();
+if (mWidget) {
+mWidget->CaptureRollupEvents(nullptr, true);
+popup->AttachedDismissalListener();
+}
+}
+UpdateKeyboardListeners();
+}
+void
+nsXULPopupManager::UpdateKeyboardListeners()
+{
+nsCOMPtr<EventTarget> newTarget;
+bool isForMenu = false;
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (item) {
+if (!item->IgnoreKeys())
+newTarget = item->Content()->GetDocument();
+isForMenu = item->PopupType() == ePopupTypeMenu;
+}
+else if (mActiveMenuBar) {
+newTarget = mActiveMenuBar->GetContent()->GetDocument();
+isForMenu = true;
+}
+if (mKeyListener != newTarget) {
+if (mKeyListener) {
+mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keypress"), this, true);
+mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keydown"), this, true);
+mKeyListener->RemoveEventListener(NS_LITERAL_STRING("keyup"), this, true);
+mKeyListener = nullptr;
+nsContentUtils::NotifyInstalledMenuKeyboardListener(false);
+}
+if (newTarget) {
+newTarget->AddEventListener(NS_LITERAL_STRING("keypress"), this, true);
+newTarget->AddEventListener(NS_LITERAL_STRING("keydown"), this, true);
+newTarget->AddEventListener(NS_LITERAL_STRING("keyup"), this, true);
+nsContentUtils::NotifyInstalledMenuKeyboardListener(isForMenu);
+mKeyListener = newTarget;
+}
+}
+}
+void
+nsXULPopupManager::UpdateMenuItems(nsIContent* aPopup)
+{
+// Walk all of the menu's children, checking to see if any of them has a
+// command attribute. If so, then several attributes must potentially be updated.
+nsCOMPtr<nsIDocument> document = aPopup->GetCurrentDoc();
+if (!document) {
+return;
+}
+for (nsCOMPtr<nsIContent> grandChild = aPopup->GetFirstChild();
+grandChild;
+grandChild = grandChild->GetNextSibling()) {
+if (grandChild->NodeInfo()->Equals(nsGkAtoms::menuitem, kNameSpaceID_XUL)) {
+// See if we have a command attribute.
+nsAutoString command;
+grandChild->GetAttr(kNameSpaceID_None, nsGkAtoms::command, command);
+if (!command.IsEmpty()) {
+// We do! Look it up in our document
+nsRefPtr<dom::Element> commandElement =
+document->GetElementById(command);
+if (commandElement) {
+nsAutoString commandValue;
+// The menu's disabled state needs to be updated to match the command.
+if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::disabled, commandValue))
+grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::disabled, commandValue, true);
+else
+grandChild->UnsetAttr(kNameSpaceID_None, nsGkAtoms::disabled, true);
+// The menu's label, accesskey checked and hidden states need to be updated
+// to match the command. Note that unlike the disabled state if the
+// command has *no* value, we assume the menu is supplying its own.
+if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::label, commandValue))
+grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::label, commandValue, true);
+if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, commandValue))
+grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, commandValue, true);
+if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::checked, commandValue))
+grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::checked, commandValue, true);
+if (commandElement->GetAttr(kNameSpaceID_None, nsGkAtoms::hidden, commandValue))
+grandChild->SetAttr(kNameSpaceID_None, nsGkAtoms::hidden, commandValue, true);
+}
+}
+}
+}
+}
+// Notify
+//
+// The item selection timer has fired, we might have to readjust the
+// selected item. There are two cases here that we are trying to deal with:
+//   (1) diagonal movement from a parent menu to a submenu passing briefly over
+//       other items, and
+//   (2) moving out from a submenu to a parent or grandparent menu.
+// In both cases, |mTimerMenu| is the menu item that might have an open submenu and
+// the first item in |mPopups| is the item the mouse is currently over, which could be
+// none of them.
+//
+// case (1):
+//  As the mouse moves from the parent item of a submenu (we'll call 'A') diagonally into the
+//  submenu, it probably passes through one or more sibilings (B). As the mouse passes
+//  through B, it becomes the current menu item and the timer is set and mTimerMenu is
+//  set to A. Before the timer fires, the mouse leaves the menu containing A and B and
+//  enters the submenus. Now when the timer fires, |mPopups| is null (!= |mTimerMenu|)
+//  so we have to see if anything in A's children is selected (recall that even disabled
+//  items are selected, the style just doesn't show it). If that is the case, we need to
+//  set the selected item back to A.
+//
+// case (2);
+//  Item A has an open submenu, and in it there is an item (B) which also has an open
+//  submenu (so there are 3 menus displayed right now). The mouse then leaves B's child
+//  submenu and selects an item that is a sibling of A, call it C. When the mouse enters C,
+//  the timer is set and |mTimerMenu| is A and |mPopups| is C. As the timer fires,
+//  the mouse is still within C. The correct behavior is to set the current item to C
+//  and close up the chain parented at A.
+//
+//  This brings up the question of is the logic of case (1) enough? The answer is no,
+//  and is discussed in bugzilla bug 29400. Case (1) asks if A's submenu has a selected
+//  child, and if it does, set the selected item to A. Because B has a submenu open, it
+//  is selected and as a result, A is set to be the selected item even though the mouse
+//  rests in C -- very wrong.
+//
+//  The solution is to use the same idea, but instead of only checking one level,
+//  drill all the way down to the deepest open submenu and check if it has something
+//  selected. Since the mouse is in a grandparent, it won't, and we know that we can
+//  safely close up A and all its children.
+//
+// The code below melds the two cases together.
+//
+nsresult
+nsXULPopupManager::Notify(nsITimer* aTimer)
+{
+if (aTimer == mCloseTimer)
+KillMenuTimer();
+return NS_OK;
+}
+void
+nsXULPopupManager::KillMenuTimer()
+{
+if (mCloseTimer && mTimerMenu) {
+mCloseTimer->Cancel();
+mCloseTimer = nullptr;
+if (mTimerMenu->IsOpen())
+HidePopup(mTimerMenu->GetContent(), false, false, true, false);
+}
+mTimerMenu = nullptr;
+}
+void
+nsXULPopupManager::CancelMenuTimer(nsMenuParent* aMenuParent)
+{
+if (mCloseTimer && mTimerMenu == aMenuParent) {
+mCloseTimer->Cancel();
+mCloseTimer = nullptr;
+mTimerMenu = nullptr;
+}
+}
+bool
+nsXULPopupManager::HandleShortcutNavigation(nsIDOMKeyEvent* aKeyEvent,
+nsMenuPopupFrame* aFrame)
+{
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (!aFrame && item)
+aFrame = item->Frame();
+if (aFrame) {
+bool action;
+nsMenuFrame* result = aFrame->FindMenuWithShortcut(aKeyEvent, action);
+if (result) {
+aFrame->ChangeMenuItem(result, false);
+if (action) {
+WidgetGUIEvent* evt = aKeyEvent->GetInternalNSEvent()->AsGUIEvent();
+nsMenuFrame* menuToOpen = result->Enter(evt);
+if (menuToOpen) {
+nsCOMPtr<nsIContent> content = menuToOpen->GetContent();
+ShowMenu(content, true, false);
+}
+}
+return true;
+}
+return false;
+}
+if (mActiveMenuBar) {
+nsMenuFrame* result = mActiveMenuBar->FindMenuWithShortcut(aKeyEvent);
+if (result) {
+mActiveMenuBar->SetActive(true);
+result->OpenMenu(true);
+return true;
+}
+}
+return false;
+}
+bool
+nsXULPopupManager::HandleKeyboardNavigation(uint32_t aKeyCode)
+{
+// navigate up through the open menus, looking for the topmost one
+// in the same hierarchy
+nsMenuChainItem* item = nullptr;
+nsMenuChainItem* nextitem = GetTopVisibleMenu();
+while (nextitem) {
+item = nextitem;
+nextitem = item->GetParent();
+if (nextitem) {
+// stop if the parent isn't a menu
+if (!nextitem->IsMenu())
+break;
+// check to make sure that the parent is actually the parent menu. It won't
+// be if the parent is in a different frame hierarchy, for example, for a
+// context menu opened on another menu.
+nsMenuParent* expectedParent = static_cast<nsMenuParent *>(nextitem->Frame());
+nsMenuFrame* menuFrame = do_QueryFrame(item->Frame()->GetParent());
+if (!menuFrame || menuFrame->GetMenuParent() != expectedParent) {
+break;
+}
+}
+}
+nsIFrame* itemFrame;
+if (item)
+itemFrame = item->Frame();
+else if (mActiveMenuBar)
+itemFrame = mActiveMenuBar;
+else
+return false;
+nsNavigationDirection theDirection;
+NS_ASSERTION(aKeyCode >= nsIDOMKeyEvent::DOM_VK_END &&
+aKeyCode <= nsIDOMKeyEvent::DOM_VK_DOWN, "Illegal key code");
+theDirection = NS_DIRECTION_FROM_KEY_CODE(itemFrame, aKeyCode);
+// if a popup is open, first check for navigation within the popup
+if (item && HandleKeyboardNavigationInPopup(item, theDirection))
+return true;
+// no popup handled the key, so check the active menubar, if any
+if (mActiveMenuBar) {
+nsMenuFrame* currentMenu = mActiveMenuBar->GetCurrentMenuItem();
+if (NS_DIRECTION_IS_INLINE(theDirection)) {
+nsMenuFrame* nextItem = (theDirection == eNavigationDirection_End) ?
+GetNextMenuItem(mActiveMenuBar, currentMenu, false) :
+GetPreviousMenuItem(mActiveMenuBar, currentMenu, false);
+mActiveMenuBar->ChangeMenuItem(nextItem, true);
+return true;
+}
+else if (NS_DIRECTION_IS_BLOCK(theDirection)) {
+// Open the menu and select its first item.
+if (currentMenu) {
+nsCOMPtr<nsIContent> content = currentMenu->GetContent();
+ShowMenu(content, true, false);
+}
+return true;
+}
+}
+return false;
+}
+bool
+nsXULPopupManager::HandleKeyboardNavigationInPopup(nsMenuChainItem* item,
+nsMenuPopupFrame* aFrame,
+nsNavigationDirection aDir)
+{
+NS_ASSERTION(aFrame, "aFrame is null");
+NS_ASSERTION(!item || item->Frame() == aFrame,
+"aFrame is expected to be equal to item->Frame()");
+nsMenuFrame* currentMenu = aFrame->GetCurrentMenuItem();
+aFrame->ClearIncrementalString();
+// This method only gets called if we're open.
+if (!currentMenu && NS_DIRECTION_IS_INLINE(aDir)) {
+// We've been opened, but we haven't had anything selected.
+// We can handle End, but our parent handles Start.
+if (aDir == eNavigationDirection_End) {
+nsMenuFrame* nextItem = GetNextMenuItem(aFrame, nullptr, true);
+if (nextItem) {
+aFrame->ChangeMenuItem(nextItem, false);
+return true;
+}
+}
+return false;
+}
+bool isContainer = false;
+bool isOpen = false;
+if (currentMenu) {
+isOpen = currentMenu->IsOpen();
+isContainer = currentMenu->IsMenu();
+if (isOpen) {
+// for an open popup, have the child process the event
+nsMenuChainItem* child = item ? item->GetChild() : nullptr;
+if (child && HandleKeyboardNavigationInPopup(child, aDir))
+return true;
+}
+else if (aDir == eNavigationDirection_End &&
+isContainer && !currentMenu->IsDisabled()) {
+// The menu is not yet open. Open it and select the first item.
+nsCOMPtr<nsIContent> content = currentMenu->GetContent();
+ShowMenu(content, true, false);
+return true;
+}
+}
+// For block progression, we can move in either direction
+if (NS_DIRECTION_IS_BLOCK(aDir) ||
+NS_DIRECTION_IS_BLOCK_TO_EDGE(aDir)) {
+nsMenuFrame* nextItem;
+if (aDir == eNavigationDirection_Before)
+nextItem = GetPreviousMenuItem(aFrame, currentMenu, true);
+else if (aDir == eNavigationDirection_After)
+nextItem = GetNextMenuItem(aFrame, currentMenu, true);
+else if (aDir == eNavigationDirection_First)
+nextItem = GetNextMenuItem(aFrame, nullptr, true);
+else
+nextItem = GetPreviousMenuItem(aFrame, nullptr, true);
+if (nextItem) {
+aFrame->ChangeMenuItem(nextItem, false);
+return true;
+}
+}
+else if (currentMenu && isContainer && isOpen) {
+if (aDir == eNavigationDirection_Start) {
+// close a submenu when Left is pressed
+nsMenuPopupFrame* popupFrame = currentMenu->GetPopup();
+if (popupFrame)
+HidePopup(popupFrame->GetContent(), false, false, false, false);
+return true;
+}
+}
+return false;
+}
+bool
+nsXULPopupManager::HandleKeyboardEventWithKeyCode(
+nsIDOMKeyEvent* aKeyEvent,
+nsMenuChainItem* aTopVisibleMenuItem)
+{
+uint32_t keyCode;
+aKeyEvent->GetKeyCode(&keyCode);
+// Escape should close panels, but the other keys should have no effect.
+if (aTopVisibleMenuItem &&
+aTopVisibleMenuItem->PopupType() != ePopupTypeMenu) {
+if (keyCode == nsIDOMKeyEvent::DOM_VK_ESCAPE) {
+HidePopup(aTopVisibleMenuItem->Content(), false, false, false, true);
+aKeyEvent->StopPropagation();
+aKeyEvent->PreventDefault();
+}
+return true;
+}
+bool consume = (mPopups || mActiveMenuBar);
+switch (keyCode) {
+case nsIDOMKeyEvent::DOM_VK_LEFT:
+case nsIDOMKeyEvent::DOM_VK_RIGHT:
+case nsIDOMKeyEvent::DOM_VK_UP:
+case nsIDOMKeyEvent::DOM_VK_DOWN:
+case nsIDOMKeyEvent::DOM_VK_HOME:
+case nsIDOMKeyEvent::DOM_VK_END:
+HandleKeyboardNavigation(keyCode);
+break;
+case nsIDOMKeyEvent::DOM_VK_ESCAPE:
+// Pressing Escape hides one level of menus only. If no menu is open,
+// check if a menubar is active and inform it that a menu closed. Even
+// though in this latter case, a menu didn't actually close, the effect
+// ends up being the same. Similar for the tab key below.
+if (aTopVisibleMenuItem) {
+HidePopup(aTopVisibleMenuItem->Content(), false, false, false, true);
+} else if (mActiveMenuBar) {
+mActiveMenuBar->MenuClosed();
+}
+break;
+case nsIDOMKeyEvent::DOM_VK_TAB:
+#ifndef XP_MACOSX
+case nsIDOMKeyEvent::DOM_VK_F10:
+#endif
+// close popups or deactivate menubar when Tab or F10 are pressed
+if (aTopVisibleMenuItem) {
+Rollup(0, nullptr, nullptr);
+} else if (mActiveMenuBar) {
+mActiveMenuBar->MenuClosed();
+}
+break;
+case nsIDOMKeyEvent::DOM_VK_RETURN: {
+// If there is a popup open, check if the current item needs to be opened.
+// Otherwise, tell the active menubar, if any, to activate the menu. The
+// Enter method will return a menu if one needs to be opened as a result.
+nsMenuFrame* menuToOpen = nullptr;
+WidgetGUIEvent* GUIEvent = aKeyEvent->GetInternalNSEvent()->AsGUIEvent();
+if (aTopVisibleMenuItem) {
+menuToOpen = aTopVisibleMenuItem->Frame()->Enter(GUIEvent);
+} else if (mActiveMenuBar) {
+menuToOpen = mActiveMenuBar->Enter(GUIEvent);
+}
+if (menuToOpen) {
+nsCOMPtr<nsIContent> content = menuToOpen->GetContent();
+ShowMenu(content, true, false);
+}
+break;
+}
+default:
+return false;
+}
+if (consume) {
+aKeyEvent->StopPropagation();
+aKeyEvent->PreventDefault();
+}
+return true;
+}
+nsMenuFrame*
+nsXULPopupManager::GetNextMenuItem(nsIFrame* aParent,
+nsMenuFrame* aStart,
+bool aIsPopup)
+{
+nsPresContext* presContext = aParent->PresContext();
+nsIFrame* immediateParent = presContext->PresShell()->
+FrameConstructor()->GetInsertionPoint(aParent->GetContent(), nullptr);
+if (!immediateParent)
+immediateParent = aParent;
+nsIFrame* currFrame = nullptr;
+if (aStart)
+currFrame = aStart->GetNextSibling();
+else
+currFrame = immediateParent->GetFirstPrincipalChild();
+while (currFrame) {
+// See if it's a menu item.
+if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
+return do_QueryFrame(currFrame);
+}
+currFrame = currFrame->GetNextSibling();
+}
+currFrame = immediateParent->GetFirstPrincipalChild();
+// Still don't have anything. Try cycling from the beginning.
+while (currFrame && currFrame != aStart) {
+// See if it's a menu item.
+if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
+return do_QueryFrame(currFrame);
+}
+currFrame = currFrame->GetNextSibling();
+}
+// No luck. Just return our start value.
+return aStart;
+}
+nsMenuFrame*
+nsXULPopupManager::GetPreviousMenuItem(nsIFrame* aParent,
+nsMenuFrame* aStart,
+bool aIsPopup)
+{
+nsPresContext* presContext = aParent->PresContext();
+nsIFrame* immediateParent = presContext->PresShell()->
+FrameConstructor()->GetInsertionPoint(aParent->GetContent(), nullptr);
+if (!immediateParent)
+immediateParent = aParent;
+const nsFrameList& frames(immediateParent->PrincipalChildList());
+nsIFrame* currFrame = nullptr;
+if (aStart)
+currFrame = aStart->GetPrevSibling();
+else
+currFrame = frames.LastChild();
+while (currFrame) {
+// See if it's a menu item.
+if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
+return do_QueryFrame(currFrame);
+}
+currFrame = currFrame->GetPrevSibling();
+}
+currFrame = frames.LastChild();
+// Still don't have anything. Try cycling from the end.
+while (currFrame && currFrame != aStart) {
+// See if it's a menu item.
+if (IsValidMenuItem(presContext, currFrame->GetContent(), aIsPopup)) {
+return do_QueryFrame(currFrame);
+}
+currFrame = currFrame->GetPrevSibling();
+}
+// No luck. Just return our start value.
+return aStart;
+}
+bool
+nsXULPopupManager::IsValidMenuItem(nsPresContext* aPresContext,
+nsIContent* aContent,
+bool aOnPopup)
+{
+int32_t ns = aContent->GetNameSpaceID();
+nsIAtom *tag = aContent->Tag();
+if (ns == kNameSpaceID_XUL) {
+if (tag != nsGkAtoms::menu && tag != nsGkAtoms::menuitem)
+return false;
+}
+else if (ns != kNameSpaceID_XHTML || !aOnPopup || tag != nsGkAtoms::option) {
+return false;
+}
+bool skipNavigatingDisabledMenuItem = true;
+if (aOnPopup) {
+skipNavigatingDisabledMenuItem =
+LookAndFeel::GetInt(LookAndFeel::eIntID_SkipNavigatingDisabledMenuItem,
+0) != 0;
+}
+return !(skipNavigatingDisabledMenuItem &&
+aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+nsGkAtoms::_true, eCaseMatters));
+}
+nsresult
+nsXULPopupManager::HandleEvent(nsIDOMEvent* aEvent)
+{
+nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aEvent);
+NS_ENSURE_TRUE(keyEvent, NS_ERROR_UNEXPECTED);
+//handlers shouldn't be triggered by non-trusted events.
+bool trustedEvent = false;
+aEvent->GetIsTrusted(&trustedEvent);
+if (!trustedEvent) {
+return NS_OK;
+}
+nsAutoString eventType;
+keyEvent->GetType(eventType);
+if (eventType.EqualsLiteral("keyup")) {
+return KeyUp(keyEvent);
+}
+if (eventType.EqualsLiteral("keydown")) {
+return KeyDown(keyEvent);
+}
+if (eventType.EqualsLiteral("keypress")) {
+return KeyPress(keyEvent);
+}
+NS_ABORT();
+return NS_OK;
+}
+nsresult
+nsXULPopupManager::KeyUp(nsIDOMKeyEvent* aKeyEvent)
+{
+// don't do anything if a menu isn't open or a menubar isn't active
+if (!mActiveMenuBar) {
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (!item || item->PopupType() != ePopupTypeMenu)
+return NS_OK;
+}
+aKeyEvent->StopPropagation();
+aKeyEvent->PreventDefault();
+return NS_OK; // I am consuming event
+}
+nsresult
+nsXULPopupManager::KeyDown(nsIDOMKeyEvent* aKeyEvent)
+{
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (item && item->Frame()->IsMenuLocked())
+return NS_OK;
+if (HandleKeyboardEventWithKeyCode(aKeyEvent, item)) {
+return NS_OK;
+}
+// don't do anything if a menu isn't open or a menubar isn't active
+if (!mActiveMenuBar && (!item || item->PopupType() != ePopupTypeMenu))
+return NS_OK;
+int32_t menuAccessKey = -1;
+// If the key just pressed is the access key (usually Alt),
+// dismiss and unfocus the menu.
+nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
+if (menuAccessKey) {
+uint32_t theChar;
+aKeyEvent->GetKeyCode(&theChar);
+if (theChar == (uint32_t)menuAccessKey) {
+bool ctrl = false;
+if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_CONTROL)
+aKeyEvent->GetCtrlKey(&ctrl);
+bool alt=false;
+if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_ALT)
+aKeyEvent->GetAltKey(&alt);
+bool shift=false;
+if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_SHIFT)
+aKeyEvent->GetShiftKey(&shift);
+bool meta=false;
+if (menuAccessKey != nsIDOMKeyEvent::DOM_VK_META)
+aKeyEvent->GetMetaKey(&meta);
+if (!(ctrl || alt || shift || meta)) {
+// The access key just went down and no other
+// modifiers are already down.
+if (mPopups)
+Rollup(0, nullptr, nullptr);
+else if (mActiveMenuBar)
+mActiveMenuBar->MenuClosed();
+}
+aKeyEvent->PreventDefault();
+}
+}
+// Since a menu was open, stop propagation of the event to keep other event
+// listeners from becoming confused.
+aKeyEvent->StopPropagation();
+return NS_OK;
+}
+nsresult
+nsXULPopupManager::KeyPress(nsIDOMKeyEvent* aKeyEvent)
+{
+// Don't check prevent default flag -- menus always get first shot at key events.
+nsMenuChainItem* item = GetTopVisibleMenu();
+if (item &&
+(item->Frame()->IsMenuLocked() || item->PopupType() != ePopupTypeMenu)) {
+return NS_OK;
+}
+nsCOMPtr<nsIDOMKeyEvent> keyEvent = do_QueryInterface(aKeyEvent);
+NS_ENSURE_TRUE(keyEvent, NS_ERROR_UNEXPECTED);
+// if a menu is open or a menubar is active, it consumes the key event
+bool consume = (mPopups || mActiveMenuBar);
+HandleShortcutNavigation(keyEvent, nullptr);
+if (consume) {
+aKeyEvent->StopPropagation();
+aKeyEvent->PreventDefault();
+}
+return NS_OK; // I am consuming event
+}
+NS_IMETHODIMP
+nsXULPopupShowingEvent::Run()
+{
+nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+if (pm) {
+pm->FirePopupShowingEvent(mPopup, mIsContextMenu, mSelectFirstItem);
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsXULPopupHidingEvent::Run()
+{
+nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+nsIDocument *document = mPopup->GetCurrentDoc();
+if (pm && document) {
+nsIPresShell* presShell = document->GetShell();
+if (presShell) {
+nsPresContext* context = presShell->GetPresContext();
+if (context) {
+pm->FirePopupHidingEvent(mPopup, mNextPopup, mLastPopup,
+context, mPopupType, mDeselectMenu, mIsRollup);
+}
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsXULMenuCommandEvent::Run()
+{
+nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+if (!pm)
+return NS_OK;
+// The order of the nsViewManager and nsIPresShell COM pointers is
+// important below.  We want the pres shell to get released before the
+// associated view manager on exit from this function.
+// See bug 54233.
+// XXXndeakin is this still needed?
+nsCOMPtr<nsIContent> popup;
+nsMenuFrame* menuFrame = do_QueryFrame(mMenu->GetPrimaryFrame());
+nsWeakFrame weakFrame(menuFrame);
+if (menuFrame && mFlipChecked) {
+if (menuFrame->IsChecked()) {
+mMenu->UnsetAttr(kNameSpaceID_None, nsGkAtoms::checked, true);
+} else {
+mMenu->SetAttr(kNameSpaceID_None, nsGkAtoms::checked,
+NS_LITERAL_STRING("true"), true);
+}
+}
+if (menuFrame && weakFrame.IsAlive()) {
+// Find the popup that the menu is inside. Below, this popup will
+// need to be hidden.
+nsIFrame* frame = menuFrame->GetParent();
+while (frame) {
+nsMenuPopupFrame* popupFrame = do_QueryFrame(frame);
+if (popupFrame) {
+popup = popupFrame->GetContent();
+break;
+}
+frame = frame->GetParent();
+}
+nsPresContext* presContext = menuFrame->PresContext();
+nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
+nsRefPtr<nsViewManager> kungFuDeathGrip = shell->GetViewManager();
+// Deselect ourselves.
+if (mCloseMenuMode != CloseMenuMode_None)
+menuFrame->SelectMenu(false);
+AutoHandlingUserInputStatePusher userInpStatePusher(mUserInput, nullptr,
+shell->GetDocument());
+nsContentUtils::DispatchXULCommand(mMenu, mIsTrusted, nullptr, shell,
+mControl, mAlt, mShift, mMeta);
+}
+if (popup && mCloseMenuMode != CloseMenuMode_None)
+pm->HidePopup(popup, mCloseMenuMode == CloseMenuMode_Auto, true, false, false);
+return NS_OK;
+}

The Tor Browser / file comparison

comparison: layout/xul/nsXULPopupManager.cpp

layout/xul/nsXULPopupManager.cpp