summaryrefslogtreecommitdiffstats
path: root/layout/xul/nsMenuPopupFrame.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/xul/nsMenuPopupFrame.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/xul/nsMenuPopupFrame.cpp')
-rw-r--r--layout/xul/nsMenuPopupFrame.cpp2442
1 files changed, 2442 insertions, 0 deletions
diff --git a/layout/xul/nsMenuPopupFrame.cpp b/layout/xul/nsMenuPopupFrame.cpp
new file mode 100644
index 000000000..6e706e49c
--- /dev/null
+++ b/layout/xul/nsMenuPopupFrame.cpp
@@ -0,0 +1,2442 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et tw=78: */
+/* 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 "nsMenuPopupFrame.h"
+#include "nsGkAtoms.h"
+#include "nsIContent.h"
+#include "nsIAtom.h"
+#include "nsPresContext.h"
+#include "nsStyleContext.h"
+#include "nsCSSRendering.h"
+#include "nsNameSpaceManager.h"
+#include "nsViewManager.h"
+#include "nsWidgetsCID.h"
+#include "nsMenuFrame.h"
+#include "nsMenuBarFrame.h"
+#include "nsPopupSetFrame.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDOMKeyEvent.h"
+#include "nsIDOMScreen.h"
+#include "nsIPresShell.h"
+#include "nsFrameManager.h"
+#include "nsIDocument.h"
+#include "nsRect.h"
+#include "nsIComponentManager.h"
+#include "nsBoxLayoutState.h"
+#include "nsIScrollableFrame.h"
+#include "nsIRootBox.h"
+#include "nsIDocShell.h"
+#include "nsReadableUtils.h"
+#include "nsUnicharUtils.h"
+#include "nsLayoutUtils.h"
+#include "nsContentUtils.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsPIWindowRoot.h"
+#include "nsIReflowCallback.h"
+#include "nsBindingManager.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIBaseWindow.h"
+#include "nsISound.h"
+#include "nsIScreenManager.h"
+#include "nsIServiceManager.h"
+#include "nsThemeConstants.h"
+#include "nsTransitionManager.h"
+#include "nsDisplayList.h"
+#include "nsIDOMXULSelectCntrlItemEl.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/PopupBoxObject.h"
+#include <algorithm>
+
+using namespace mozilla;
+using mozilla::dom::PopupBoxObject;
+
+int8_t nsMenuPopupFrame::sDefaultLevelIsTop = -1;
+
+DOMTimeStamp nsMenuPopupFrame::sLastKeyTime = 0;
+
+// XXX, kyle.yuan@sun.com, there are 4 definitions for the same purpose:
+// nsMenuPopupFrame.h, nsListControlFrame.cpp, listbox.xml, tree.xml
+// need to find a good place to put them together.
+// if someone changes one, please also change the other.
+uint32_t nsMenuPopupFrame::sTimeoutOfIncrementalSearch = 1000;
+
+const char* kPrefIncrementalSearchTimeout =
+ "ui.menu.incremental_search.timeout";
+
+// NS_NewMenuPopupFrame
+//
+// Wrapper for creating a new menu popup container
+//
+nsIFrame*
+NS_NewMenuPopupFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+ return new (aPresShell) nsMenuPopupFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsMenuPopupFrame)
+
+NS_QUERYFRAME_HEAD(nsMenuPopupFrame)
+ NS_QUERYFRAME_ENTRY(nsMenuPopupFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
+
+//
+// nsMenuPopupFrame ctor
+//
+nsMenuPopupFrame::nsMenuPopupFrame(nsStyleContext* aContext)
+ :nsBoxFrame(aContext),
+ mCurrentMenu(nullptr),
+ mPrefSize(-1, -1),
+ mLastClientOffset(0, 0),
+ mPopupType(ePopupTypePanel),
+ mPopupState(ePopupClosed),
+ mPopupAlignment(POPUPALIGNMENT_NONE),
+ mPopupAnchor(POPUPALIGNMENT_NONE),
+ mPosition(POPUPPOSITION_UNKNOWN),
+ mConsumeRollupEvent(PopupBoxObject::ROLLUP_DEFAULT),
+ mFlip(FlipType_Default),
+ mIsOpenChanged(false),
+ mIsContextMenu(false),
+ mAdjustOffsetForContextMenu(false),
+ mGeneratedChildren(false),
+ mMenuCanOverlapOSBar(false),
+ mShouldAutoPosition(true),
+ mInContentShell(true),
+ mIsMenuLocked(false),
+ mMouseTransparent(false),
+ mHFlip(false),
+ mVFlip(false),
+ mAnchorType(MenuPopupAnchorType_Node)
+{
+ // the preference name is backwards here. True means that the 'top' level is
+ // the default, and false means that the 'parent' level is the default.
+ if (sDefaultLevelIsTop >= 0)
+ return;
+ sDefaultLevelIsTop =
+ Preferences::GetBool("ui.panel.default_level_parent", false);
+ Preferences::AddUintVarCache(&sTimeoutOfIncrementalSearch,
+ kPrefIncrementalSearchTimeout, 1000);
+} // ctor
+
+void
+nsMenuPopupFrame::Init(nsIContent* aContent,
+ nsContainerFrame* aParent,
+ nsIFrame* aPrevInFlow)
+{
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+
+ // lookup if we're allowed to overlap the OS bar (menubar/taskbar) from the
+ // look&feel object
+ mMenuCanOverlapOSBar =
+ LookAndFeel::GetInt(LookAndFeel::eIntID_MenusCanOverlapOSBar) != 0;
+
+ CreatePopupView();
+
+ // XXX Hack. The popup's view should float above all other views,
+ // so we use the nsView::SetFloating() to tell the view manager
+ // about that constraint.
+ nsView* ourView = GetView();
+ nsViewManager* viewManager = ourView->GetViewManager();
+ viewManager->SetViewFloating(ourView, true);
+
+ mPopupType = ePopupTypePanel;
+ nsIDocument* doc = aContent->OwnerDoc();
+ int32_t namespaceID;
+ nsCOMPtr<nsIAtom> tag = doc->BindingManager()->ResolveTag(aContent, &namespaceID);
+ if (namespaceID == kNameSpaceID_XUL) {
+ if (tag == nsGkAtoms::menupopup || tag == nsGkAtoms::popup)
+ mPopupType = ePopupTypeMenu;
+ else if (tag == nsGkAtoms::tooltip)
+ mPopupType = ePopupTypeTooltip;
+ }
+
+ nsCOMPtr<nsIDocShellTreeItem> dsti = PresContext()->GetDocShell();
+ if (dsti && dsti->ItemType() == nsIDocShellTreeItem::typeChrome) {
+ mInContentShell = false;
+ }
+
+ // To improve performance, create the widget for the popup only if it is not
+ // a leaf. Leaf popups such as menus will create their widgets later when
+ // the popup opens.
+ if (!IsLeaf() && !ourView->HasWidget()) {
+ CreateWidgetForView(ourView);
+ }
+
+ if (aContent->NodeInfo()->Equals(nsGkAtoms::tooltip, kNameSpaceID_XUL) &&
+ aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::_default,
+ nsGkAtoms::_true, eIgnoreCase)) {
+ nsIRootBox* rootBox =
+ nsIRootBox::GetRootBox(PresContext()->GetPresShell());
+ if (rootBox) {
+ rootBox->SetDefaultTooltip(aContent);
+ }
+ }
+
+ AddStateBits(NS_FRAME_IN_POPUP);
+}
+
+bool
+nsMenuPopupFrame::IsNoAutoHide() const
+{
+ // Panels with noautohide="true" don't hide when the mouse is clicked
+ // outside of them, or when another application is made active. Non-autohide
+ // panels cannot be used in content windows.
+ return (!mInContentShell && mPopupType == ePopupTypePanel &&
+ mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::noautohide,
+ nsGkAtoms::_true, eIgnoreCase));
+}
+
+nsPopupLevel
+nsMenuPopupFrame::PopupLevel(bool aIsNoAutoHide) const
+{
+ // The popup level is determined as follows, in this order:
+ // 1. non-panels (menus and tooltips) are always topmost
+ // 2. any specified level attribute
+ // 3. if a titlebar attribute is set, use the 'floating' level
+ // 4. if this is a noautohide panel, use the 'parent' level
+ // 5. use the platform-specific default level
+
+ // If this is not a panel, this is always a top-most popup.
+ if (mPopupType != ePopupTypePanel)
+ return ePopupLevelTop;
+
+ // If the level attribute has been set, use that.
+ static nsIContent::AttrValuesArray strings[] =
+ {&nsGkAtoms::top, &nsGkAtoms::parent, &nsGkAtoms::floating, nullptr};
+ switch (mContent->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::level,
+ strings, eCaseMatters)) {
+ case 0:
+ return ePopupLevelTop;
+ case 1:
+ return ePopupLevelParent;
+ case 2:
+ return ePopupLevelFloating;
+ }
+
+ // Panels with titlebars most likely want to be floating popups.
+ if (mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::titlebar))
+ return ePopupLevelFloating;
+
+ // If this panel is a noautohide panel, the default is the parent level.
+ if (aIsNoAutoHide)
+ return ePopupLevelParent;
+
+ // Otherwise, the result depends on the platform.
+ return sDefaultLevelIsTop ? ePopupLevelTop : ePopupLevelParent;
+}
+
+void
+nsMenuPopupFrame::EnsureWidget()
+{
+ nsView* ourView = GetView();
+ if (!ourView->HasWidget()) {
+ NS_ASSERTION(!mGeneratedChildren && !PrincipalChildList().FirstChild(),
+ "Creating widget for MenuPopupFrame with children");
+ CreateWidgetForView(ourView);
+ }
+}
+
+nsresult
+nsMenuPopupFrame::CreateWidgetForView(nsView* aView)
+{
+ // Create a widget for ourselves.
+ nsWidgetInitData widgetData;
+ widgetData.mWindowType = eWindowType_popup;
+ widgetData.mBorderStyle = eBorderStyle_default;
+ widgetData.clipSiblings = true;
+ widgetData.mPopupHint = mPopupType;
+ widgetData.mNoAutoHide = IsNoAutoHide();
+
+ if (!mInContentShell) {
+ // A drag popup may be used for non-static translucent drag feedback
+ if (mPopupType == ePopupTypePanel &&
+ mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+ nsGkAtoms::drag, eIgnoreCase)) {
+ widgetData.mIsDragPopup = true;
+ }
+
+ // If mousethrough="always" is set directly on the popup, then the widget
+ // should ignore mouse events, passing them through to the content behind.
+ mMouseTransparent = GetStateBits() & NS_FRAME_MOUSE_THROUGH_ALWAYS;
+ widgetData.mMouseTransparent = mMouseTransparent;
+ }
+
+ nsAutoString title;
+ if (mContent && widgetData.mNoAutoHide) {
+ if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::titlebar,
+ nsGkAtoms::normal, eCaseMatters)) {
+ widgetData.mBorderStyle = eBorderStyle_title;
+
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, title);
+
+ if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::close,
+ nsGkAtoms::_true, eCaseMatters)) {
+ widgetData.mBorderStyle =
+ static_cast<enum nsBorderStyle>(widgetData.mBorderStyle | eBorderStyle_close);
+ }
+ }
+ }
+
+ nsTransparencyMode mode = nsLayoutUtils::GetFrameTransparency(this, this);
+ nsIContent* parentContent = GetContent()->GetParent();
+ nsIAtom *tag = nullptr;
+ if (parentContent && parentContent->IsXULElement())
+ tag = parentContent->NodeInfo()->NameAtom();
+ widgetData.mSupportTranslucency = mode == eTransparencyTransparent;
+ widgetData.mDropShadow = !(mode == eTransparencyTransparent || tag == nsGkAtoms::menulist);
+ widgetData.mPopupLevel = PopupLevel(widgetData.mNoAutoHide);
+
+ // panels which have a parent level need a parent widget. This allows them to
+ // always appear in front of the parent window but behind other windows that
+ // should be in front of it.
+ nsCOMPtr<nsIWidget> parentWidget;
+ if (widgetData.mPopupLevel != ePopupLevelTop) {
+ nsCOMPtr<nsIDocShellTreeItem> dsti = PresContext()->GetDocShell();
+ if (!dsti)
+ return NS_ERROR_FAILURE;
+
+ nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+ dsti->GetTreeOwner(getter_AddRefs(treeOwner));
+ if (!treeOwner) return NS_ERROR_FAILURE;
+
+ nsCOMPtr<nsIBaseWindow> baseWindow(do_QueryInterface(treeOwner));
+ if (baseWindow)
+ baseWindow->GetMainWidget(getter_AddRefs(parentWidget));
+ }
+
+ nsresult rv = aView->CreateWidgetForPopup(&widgetData, parentWidget,
+ true, true);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsIWidget* widget = aView->GetWidget();
+ widget->SetTransparencyMode(mode);
+ widget->SetWindowShadowStyle(GetShadowStyle());
+
+ // most popups don't have a title so avoid setting the title if there isn't one
+ if (!title.IsEmpty()) {
+ widget->SetTitle(title);
+ }
+
+ return NS_OK;
+}
+
+uint8_t
+nsMenuPopupFrame::GetShadowStyle()
+{
+ uint8_t shadow = StyleUIReset()->mWindowShadow;
+ if (shadow != NS_STYLE_WINDOW_SHADOW_DEFAULT)
+ return shadow;
+
+ switch (StyleDisplay()->mAppearance) {
+ case NS_THEME_TOOLTIP:
+ return NS_STYLE_WINDOW_SHADOW_TOOLTIP;
+ case NS_THEME_MENUPOPUP:
+ return NS_STYLE_WINDOW_SHADOW_MENU;
+ }
+ return NS_STYLE_WINDOW_SHADOW_DEFAULT;
+}
+
+NS_IMETHODIMP nsXULPopupShownEvent::Run()
+{
+ nsMenuPopupFrame* popup = do_QueryFrame(mPopup->GetPrimaryFrame());
+ // Set the state to visible if the popup is still open.
+ if (popup && popup->IsOpen()) {
+ popup->SetPopupState(ePopupShown);
+ }
+
+ WidgetMouseEvent event(true, eXULPopupShown, nullptr,
+ WidgetMouseEvent::eReal);
+ return EventDispatcher::Dispatch(mPopup, mPresContext, &event);
+}
+
+NS_IMETHODIMP nsXULPopupShownEvent::HandleEvent(nsIDOMEvent* aEvent)
+{
+ nsMenuPopupFrame* popup = do_QueryFrame(mPopup->GetPrimaryFrame());
+ nsCOMPtr<nsIDOMEventTarget> eventTarget;
+ aEvent->GetTarget(getter_AddRefs(eventTarget));
+ // Ignore events not targeted at the popup itself (ie targeted at
+ // descendants):
+ if (!SameCOMIdentity(mPopup, eventTarget)) {
+ return NS_OK;
+ }
+ if (popup) {
+ // ResetPopupShownDispatcher will delete the reference to this, so keep
+ // another one until Run is finished.
+ RefPtr<nsXULPopupShownEvent> event = this;
+ // Only call Run if it the dispatcher was assigned. This avoids calling the
+ // Run method if the transitionend event fires multiple times.
+ if (popup->ClearPopupShownDispatcher()) {
+ return Run();
+ }
+ }
+
+ CancelListener();
+ return NS_OK;
+}
+
+void nsXULPopupShownEvent::CancelListener()
+{
+ mPopup->RemoveSystemEventListener(NS_LITERAL_STRING("transitionend"), this, false);
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsXULPopupShownEvent, Runnable, nsIDOMEventListener);
+
+void
+nsMenuPopupFrame::SetInitialChildList(ChildListID aListID,
+ nsFrameList& aChildList)
+{
+ // unless the list is empty, indicate that children have been generated.
+ if (aListID == kPrincipalList && aChildList.NotEmpty()) {
+ mGeneratedChildren = true;
+ }
+ nsBoxFrame::SetInitialChildList(aListID, aChildList);
+}
+
+bool
+nsMenuPopupFrame::IsLeaf() const
+{
+ if (mGeneratedChildren)
+ return false;
+
+ if (mPopupType != ePopupTypeMenu) {
+ // any panel with a type attribute, such as the autocomplete popup,
+ // is always generated right away.
+ return !mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::type);
+ }
+
+ // menu popups generate their child frames lazily only when opened, so
+ // behave like a leaf frame. However, generate child frames normally if
+ // the parent menu has a sizetopopup attribute. In this case the size of
+ // the parent menu is dependent on the size of the popup, so the frames
+ // need to exist in order to calculate this size.
+ nsIContent* parentContent = mContent->GetParent();
+ return (parentContent &&
+ !parentContent->HasAttr(kNameSpaceID_None, nsGkAtoms::sizetopopup));
+}
+
+void
+nsMenuPopupFrame::LayoutPopup(nsBoxLayoutState& aState, nsIFrame* aParentMenu,
+ nsIFrame* aAnchor, bool aSizedToPopup)
+{
+ if (!mGeneratedChildren)
+ return;
+
+ SchedulePaint();
+
+ bool shouldPosition = true;
+ bool isOpen = IsOpen();
+ if (!isOpen) {
+ // if the popup is not open, only do layout while showing or if the menu
+ // is sized to the popup
+ shouldPosition = (mPopupState == ePopupShowing || mPopupState == ePopupPositioning);
+ if (!shouldPosition && !aSizedToPopup) {
+ RemoveStateBits(NS_FRAME_FIRST_REFLOW);
+ return;
+ }
+ }
+
+ // if the popup has just been opened, make sure the scrolled window is at 0,0
+ // Don't scroll menulists as they will scroll to their selected item on their own.
+ if (mIsOpenChanged && !IsMenuList()) {
+ nsIScrollableFrame *scrollframe = do_QueryFrame(nsBox::GetChildXULBox(this));
+ if (scrollframe) {
+ nsWeakFrame weakFrame(this);
+ scrollframe->ScrollTo(nsPoint(0,0), nsIScrollableFrame::INSTANT);
+ if (!weakFrame.IsAlive()) {
+ return;
+ }
+ }
+ }
+
+ // get the preferred, minimum and maximum size. If the menu is sized to the
+ // popup, then the popup's width is the menu's width.
+ nsSize prefSize = GetXULPrefSize(aState);
+ nsSize minSize = GetXULMinSize(aState);
+ nsSize maxSize = GetXULMaxSize(aState);
+
+ if (aSizedToPopup) {
+ prefSize.width = aParentMenu->GetRect().width;
+ }
+ prefSize = BoundsCheck(minSize, prefSize, maxSize);
+
+ // if the size changed then set the bounds to be the preferred size
+ bool sizeChanged = (mPrefSize != prefSize);
+ if (sizeChanged) {
+ SetXULBounds(aState, nsRect(0, 0, prefSize.width, prefSize.height), false);
+ mPrefSize = prefSize;
+ }
+
+ bool needCallback = false;
+ if (shouldPosition) {
+ SetPopupPosition(aAnchor, false, aSizedToPopup, mPopupState == ePopupPositioning);
+ needCallback = true;
+ }
+
+ nsRect bounds(GetRect());
+ XULLayout(aState);
+
+ // if the width or height changed, readjust the popup position. This is a
+ // special case for tooltips where the preferred height doesn't include the
+ // real height for its inline element, but does once it is laid out.
+ // This is bug 228673 which doesn't have a simple fix.
+ bool rePosition = shouldPosition && (mPosition == POPUPPOSITION_SELECTION);
+ if (!aParentMenu) {
+ nsSize newsize = GetSize();
+ if (newsize.width > bounds.width || newsize.height > bounds.height) {
+ // the size after layout was larger than the preferred size,
+ // so set the preferred size accordingly
+ mPrefSize = newsize;
+ if (isOpen) {
+ rePosition = true;
+ needCallback = true;
+ }
+ }
+ }
+
+ if (rePosition) {
+ SetPopupPosition(aAnchor, false, aSizedToPopup, false);
+ }
+
+ nsPresContext* pc = PresContext();
+ nsView* view = GetView();
+
+ if (sizeChanged) {
+ // If the size of the popup changed, apply any size constraints.
+ nsIWidget* widget = view->GetWidget();
+ if (widget) {
+ SetSizeConstraints(pc, widget, minSize, maxSize);
+ }
+ }
+
+ if (isOpen) {
+ nsViewManager* viewManager = view->GetViewManager();
+ nsRect rect = GetRect();
+ rect.x = rect.y = 0;
+ viewManager->ResizeView(view, rect);
+
+ if (mPopupState == ePopupOpening) {
+ mPopupState = ePopupVisible;
+ }
+
+ viewManager->SetViewVisibility(view, nsViewVisibility_kShow);
+ nsContainerFrame::SyncFrameViewProperties(pc, this, nullptr, view, 0);
+ }
+
+ // finally, if the popup just opened, send a popupshown event
+ if (mIsOpenChanged) {
+ mIsOpenChanged = false;
+
+ // Make sure the current selection in a menulist is visible.
+ if (IsMenuList() && mCurrentMenu) {
+ EnsureMenuItemIsVisible(mCurrentMenu);
+ }
+
+#ifndef MOZ_WIDGET_GTK
+ // If the animate attribute is set to open, check for a transition and wait
+ // for it to finish before firing the popupshown event.
+ if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::animate,
+ nsGkAtoms::open, eCaseMatters) &&
+ nsLayoutUtils::HasCurrentTransitions(this)) {
+ mPopupShownDispatcher = new nsXULPopupShownEvent(mContent, pc);
+ mContent->AddSystemEventListener(NS_LITERAL_STRING("transitionend"),
+ mPopupShownDispatcher, false, false);
+ return;
+ }
+#endif
+
+ // If there are no transitions, fire the popupshown event right away.
+ nsCOMPtr<nsIRunnable> event = new nsXULPopupShownEvent(GetContent(), pc);
+ NS_DispatchToCurrentThread(event);
+ }
+
+ if (needCallback && !mReflowCallbackData.mPosted) {
+ pc->PresShell()->PostReflowCallback(this);
+ mReflowCallbackData.MarkPosted(aAnchor, aSizedToPopup);
+ }
+}
+
+bool
+nsMenuPopupFrame::ReflowFinished()
+{
+ SetPopupPosition(mReflowCallbackData.mAnchor, false, mReflowCallbackData.mSizedToPopup, false);
+
+ mReflowCallbackData.Clear();
+
+ return false;
+}
+
+void
+nsMenuPopupFrame::ReflowCallbackCanceled()
+{
+ mReflowCallbackData.Clear();
+}
+
+bool
+nsMenuPopupFrame::IsMenuList()
+{
+ nsIFrame* parentMenu = GetParent();
+ if (!parentMenu) {
+ return false;
+ }
+
+ nsCOMPtr<nsIDOMXULMenuListElement> menulist = do_QueryInterface(parentMenu->GetContent());
+ return menulist != nullptr;
+}
+
+nsIContent*
+nsMenuPopupFrame::GetTriggerContent(nsMenuPopupFrame* aMenuPopupFrame)
+{
+ while (aMenuPopupFrame) {
+ if (aMenuPopupFrame->mTriggerContent)
+ return aMenuPopupFrame->mTriggerContent;
+
+ // check up the menu hierarchy until a popup with a trigger node is found
+ nsMenuFrame* menuFrame = do_QueryFrame(aMenuPopupFrame->GetParent());
+ if (!menuFrame)
+ break;
+
+ nsMenuParent* parentPopup = menuFrame->GetMenuParent();
+ if (!parentPopup || !parentPopup->IsMenu())
+ break;
+
+ aMenuPopupFrame = static_cast<nsMenuPopupFrame *>(parentPopup);
+ }
+
+ return nullptr;
+}
+
+void
+nsMenuPopupFrame::InitPositionFromAnchorAlign(const nsAString& aAnchor,
+ const nsAString& aAlign)
+{
+ mTriggerContent = nullptr;
+
+ if (aAnchor.EqualsLiteral("topleft"))
+ mPopupAnchor = POPUPALIGNMENT_TOPLEFT;
+ else if (aAnchor.EqualsLiteral("topright"))
+ mPopupAnchor = POPUPALIGNMENT_TOPRIGHT;
+ else if (aAnchor.EqualsLiteral("bottomleft"))
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMLEFT;
+ else if (aAnchor.EqualsLiteral("bottomright"))
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMRIGHT;
+ else if (aAnchor.EqualsLiteral("leftcenter"))
+ mPopupAnchor = POPUPALIGNMENT_LEFTCENTER;
+ else if (aAnchor.EqualsLiteral("rightcenter"))
+ mPopupAnchor = POPUPALIGNMENT_RIGHTCENTER;
+ else if (aAnchor.EqualsLiteral("topcenter"))
+ mPopupAnchor = POPUPALIGNMENT_TOPCENTER;
+ else if (aAnchor.EqualsLiteral("bottomcenter"))
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMCENTER;
+ else
+ mPopupAnchor = POPUPALIGNMENT_NONE;
+
+ if (aAlign.EqualsLiteral("topleft"))
+ mPopupAlignment = POPUPALIGNMENT_TOPLEFT;
+ else if (aAlign.EqualsLiteral("topright"))
+ mPopupAlignment = POPUPALIGNMENT_TOPRIGHT;
+ else if (aAlign.EqualsLiteral("bottomleft"))
+ mPopupAlignment = POPUPALIGNMENT_BOTTOMLEFT;
+ else if (aAlign.EqualsLiteral("bottomright"))
+ mPopupAlignment = POPUPALIGNMENT_BOTTOMRIGHT;
+ else
+ mPopupAlignment = POPUPALIGNMENT_NONE;
+
+ mPosition = POPUPPOSITION_UNKNOWN;
+}
+
+void
+nsMenuPopupFrame::InitializePopup(nsIContent* aAnchorContent,
+ nsIContent* aTriggerContent,
+ const nsAString& aPosition,
+ int32_t aXPos, int32_t aYPos,
+ MenuPopupAnchorType aAnchorType,
+ bool aAttributesOverride)
+{
+ EnsureWidget();
+
+ mPopupState = ePopupShowing;
+ mAnchorContent = aAnchorContent;
+ mTriggerContent = aTriggerContent;
+ mXPos = aXPos;
+ mYPos = aYPos;
+ mAdjustOffsetForContextMenu = false;
+ mVFlip = false;
+ mHFlip = false;
+ mAlignmentOffset = 0;
+
+ mAnchorType = aAnchorType;
+
+ // if aAttributesOverride is true, then the popupanchor, popupalign and
+ // position attributes on the <popup> override those values passed in.
+ // If false, those attributes are only used if the values passed in are empty
+ if (aAnchorContent || aAnchorType == MenuPopupAnchorType_Rect) {
+ nsAutoString anchor, align, position, flip;
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::popupanchor, anchor);
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::popupalign, align);
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::position, position);
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::flip, flip);
+
+ if (aAttributesOverride) {
+ // if the attributes are set, clear the offset position. Otherwise,
+ // the offset is used to adjust the position from the anchor point
+ if (anchor.IsEmpty() && align.IsEmpty() && position.IsEmpty())
+ position.Assign(aPosition);
+ else
+ mXPos = mYPos = 0;
+ }
+ else if (!aPosition.IsEmpty()) {
+ position.Assign(aPosition);
+ }
+
+ if (flip.EqualsLiteral("none")) {
+ mFlip = FlipType_None;
+ } else if (flip.EqualsLiteral("both")) {
+ mFlip = FlipType_Both;
+ } else if (flip.EqualsLiteral("slide")) {
+ mFlip = FlipType_Slide;
+ }
+
+ position.CompressWhitespace();
+ int32_t spaceIdx = position.FindChar(' ');
+ // if there is a space in the position, assume it is the anchor and
+ // alignment as two separate tokens.
+ if (spaceIdx >= 0) {
+ InitPositionFromAnchorAlign(Substring(position, 0, spaceIdx), Substring(position, spaceIdx + 1));
+ }
+ else if (position.EqualsLiteral("before_start")) {
+ mPopupAnchor = POPUPALIGNMENT_TOPLEFT;
+ mPopupAlignment = POPUPALIGNMENT_BOTTOMLEFT;
+ mPosition = POPUPPOSITION_BEFORESTART;
+ }
+ else if (position.EqualsLiteral("before_end")) {
+ mPopupAnchor = POPUPALIGNMENT_TOPRIGHT;
+ mPopupAlignment = POPUPALIGNMENT_BOTTOMRIGHT;
+ mPosition = POPUPPOSITION_BEFOREEND;
+ }
+ else if (position.EqualsLiteral("after_start")) {
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMLEFT;
+ mPopupAlignment = POPUPALIGNMENT_TOPLEFT;
+ mPosition = POPUPPOSITION_AFTERSTART;
+ }
+ else if (position.EqualsLiteral("after_end")) {
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMRIGHT;
+ mPopupAlignment = POPUPALIGNMENT_TOPRIGHT;
+ mPosition = POPUPPOSITION_AFTEREND;
+ }
+ else if (position.EqualsLiteral("start_before")) {
+ mPopupAnchor = POPUPALIGNMENT_TOPLEFT;
+ mPopupAlignment = POPUPALIGNMENT_TOPRIGHT;
+ mPosition = POPUPPOSITION_STARTBEFORE;
+ }
+ else if (position.EqualsLiteral("start_after")) {
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMLEFT;
+ mPopupAlignment = POPUPALIGNMENT_BOTTOMRIGHT;
+ mPosition = POPUPPOSITION_STARTAFTER;
+ }
+ else if (position.EqualsLiteral("end_before")) {
+ mPopupAnchor = POPUPALIGNMENT_TOPRIGHT;
+ mPopupAlignment = POPUPALIGNMENT_TOPLEFT;
+ mPosition = POPUPPOSITION_ENDBEFORE;
+ }
+ else if (position.EqualsLiteral("end_after")) {
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMRIGHT;
+ mPopupAlignment = POPUPALIGNMENT_BOTTOMLEFT;
+ mPosition = POPUPPOSITION_ENDAFTER;
+ }
+ else if (position.EqualsLiteral("overlap")) {
+ mPopupAnchor = POPUPALIGNMENT_TOPLEFT;
+ mPopupAlignment = POPUPALIGNMENT_TOPLEFT;
+ mPosition = POPUPPOSITION_OVERLAP;
+ }
+ else if (position.EqualsLiteral("after_pointer")) {
+ mPopupAnchor = POPUPALIGNMENT_TOPLEFT;
+ mPopupAlignment = POPUPALIGNMENT_TOPLEFT;
+ mPosition = POPUPPOSITION_AFTERPOINTER;
+ // XXXndeakin this is supposed to anchor vertically after, but with the
+ // horizontal position as the mouse pointer.
+ mYPos += 21;
+ }
+ else if (position.EqualsLiteral("selection")) {
+ mPopupAnchor = POPUPALIGNMENT_BOTTOMLEFT;
+ mPopupAlignment = POPUPALIGNMENT_TOPLEFT;
+ mPosition = POPUPPOSITION_SELECTION;
+ }
+ else {
+ InitPositionFromAnchorAlign(anchor, align);
+ }
+ }
+
+ mScreenRect = nsIntRect(-1, -1, 0, 0);
+
+ if (aAttributesOverride) {
+ // Use |left| and |top| dimension attributes to position the popup if
+ // present, as they may have been persisted.
+ nsAutoString left, top;
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::left, left);
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::top, top);
+
+ nsresult err;
+ if (!left.IsEmpty()) {
+ int32_t x = left.ToInteger(&err);
+ if (NS_SUCCEEDED(err))
+ mScreenRect.x = x;
+ }
+ if (!top.IsEmpty()) {
+ int32_t y = top.ToInteger(&err);
+ if (NS_SUCCEEDED(err))
+ mScreenRect.y = y;
+ }
+ }
+}
+
+void
+nsMenuPopupFrame::InitializePopupAtScreen(nsIContent* aTriggerContent,
+ int32_t aXPos, int32_t aYPos,
+ bool aIsContextMenu)
+{
+ EnsureWidget();
+
+ mPopupState = ePopupShowing;
+ mAnchorContent = nullptr;
+ mTriggerContent = aTriggerContent;
+ mScreenRect = nsIntRect(aXPos, aYPos, 0, 0);
+ mXPos = 0;
+ mYPos = 0;
+ mFlip = FlipType_Default;
+ mPopupAnchor = POPUPALIGNMENT_NONE;
+ mPopupAlignment = POPUPALIGNMENT_NONE;
+ mPosition = POPUPPOSITION_UNKNOWN;
+ mIsContextMenu = aIsContextMenu;
+ mAdjustOffsetForContextMenu = aIsContextMenu;
+ mAnchorType = MenuPopupAnchorType_Point;
+}
+
+void
+nsMenuPopupFrame::InitializePopupAtRect(nsIContent* aTriggerContent,
+ const nsAString& aPosition,
+ const nsIntRect& aRect,
+ bool aAttributesOverride)
+{
+ InitializePopup(nullptr, aTriggerContent, aPosition, 0, 0,
+ MenuPopupAnchorType_Rect, aAttributesOverride);
+ mScreenRect = aRect;
+}
+
+void
+nsMenuPopupFrame::InitializePopupWithAnchorAlign(nsIContent* aAnchorContent,
+ nsAString& aAnchor,
+ nsAString& aAlign,
+ int32_t aXPos, int32_t aYPos)
+{
+ EnsureWidget();
+
+ mPopupState = ePopupShowing;
+ mAdjustOffsetForContextMenu = false;
+ mFlip = FlipType_Default;
+
+ // this popup opening function is provided for backwards compatibility
+ // only. It accepts either coordinates or an anchor and alignment value
+ // but doesn't use both together.
+ if (aXPos == -1 && aYPos == -1) {
+ mAnchorContent = aAnchorContent;
+ mAnchorType = MenuPopupAnchorType_Node;
+ mScreenRect = nsIntRect(-1, -1, 0, 0);
+ mXPos = 0;
+ mYPos = 0;
+ InitPositionFromAnchorAlign(aAnchor, aAlign);
+ }
+ else {
+ mAnchorContent = nullptr;
+ mAnchorType = MenuPopupAnchorType_Point;
+ mPopupAnchor = POPUPALIGNMENT_NONE;
+ mPopupAlignment = POPUPALIGNMENT_NONE;
+ mPosition = POPUPPOSITION_UNKNOWN;
+ mScreenRect = nsIntRect(aXPos, aYPos, 0, 0);
+ mXPos = aXPos;
+ mYPos = aYPos;
+ }
+}
+
+void
+nsMenuPopupFrame::ShowPopup(bool aIsContextMenu)
+{
+ mIsContextMenu = aIsContextMenu;
+
+ InvalidateFrameSubtree();
+
+ if (mPopupState == ePopupShowing || mPopupState == ePopupPositioning) {
+ mPopupState = ePopupOpening;
+ mIsOpenChanged = true;
+
+ // Clear mouse capture when a popup is opened.
+ if (mPopupType == ePopupTypeMenu) {
+ EventStateManager* activeESM =
+ static_cast<EventStateManager*>(
+ EventStateManager::GetActiveEventStateManager());
+ if (activeESM) {
+ EventStateManager::ClearGlobalActiveContent(activeESM);
+ }
+
+ nsIPresShell::SetCapturingContent(nullptr, 0);
+ }
+
+ nsMenuFrame* menuFrame = do_QueryFrame(GetParent());
+ if (menuFrame) {
+ nsWeakFrame weakFrame(this);
+ menuFrame->PopupOpened();
+ if (!weakFrame.IsAlive())
+ return;
+ }
+
+ // do we need an actual reflow here?
+ // is SetPopupPosition all that is needed?
+ PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,
+ NS_FRAME_HAS_DIRTY_CHILDREN);
+
+ if (mPopupType == ePopupTypeMenu) {
+ nsCOMPtr<nsISound> sound(do_CreateInstance("@mozilla.org/sound;1"));
+ if (sound)
+ sound->PlayEventSound(nsISound::EVENT_MENU_POPUP);
+ }
+ }
+
+ mShouldAutoPosition = true;
+}
+
+void
+nsMenuPopupFrame::HidePopup(bool aDeselectMenu, nsPopupState aNewState)
+{
+ NS_ASSERTION(aNewState == ePopupClosed || aNewState == ePopupInvisible,
+ "popup being set to unexpected state");
+
+ ClearPopupShownDispatcher();
+
+ // don't hide the popup when it isn't open
+ if (mPopupState == ePopupClosed || mPopupState == ePopupShowing ||
+ mPopupState == ePopupPositioning)
+ return;
+
+ // clear the trigger content if the popup is being closed. But don't clear
+ // it if the popup is just being made invisible as a popuphiding or command
+ // event may want to retrieve it.
+ if (aNewState == ePopupClosed) {
+ // if the popup had a trigger node set, clear the global window popup node
+ // as well
+ if (mTriggerContent) {
+ nsIDocument* doc = mContent->GetUncomposedDoc();
+ if (doc) {
+ if (nsPIDOMWindowOuter* win = doc->GetWindow()) {
+ nsCOMPtr<nsPIWindowRoot> root = win->GetTopWindowRoot();
+ if (root) {
+ root->SetPopupNode(nullptr);
+ }
+ }
+ }
+ }
+ mTriggerContent = nullptr;
+ mAnchorContent = nullptr;
+ }
+
+ // when invisible and about to be closed, HidePopup has already been called,
+ // so just set the new state to closed and return
+ if (mPopupState == ePopupInvisible) {
+ if (aNewState == ePopupClosed)
+ mPopupState = ePopupClosed;
+ return;
+ }
+
+ mPopupState = aNewState;
+
+ if (IsMenu())
+ SetCurrentMenuItem(nullptr);
+
+ mIncrementalString.Truncate();
+
+ LockMenuUntilClosed(false);
+
+ mIsOpenChanged = false;
+ mCurrentMenu = nullptr; // make sure no current menu is set
+ mHFlip = mVFlip = false;
+
+ nsView* view = GetView();
+ nsViewManager* viewManager = view->GetViewManager();
+ viewManager->SetViewVisibility(view, nsViewVisibility_kHide);
+
+ FireDOMEvent(NS_LITERAL_STRING("DOMMenuInactive"), mContent);
+
+ // XXX, bug 137033, In Windows, if mouse is outside the window when the menupopup closes, no
+ // mouse_enter/mouse_exit event will be fired to clear current hover state, we should clear it manually.
+ // This code may not the best solution, but we can leave it here until we find the better approach.
+ NS_ASSERTION(mContent->IsElement(), "How do we have a non-element?");
+ EventStates state = mContent->AsElement()->State();
+
+ if (state.HasState(NS_EVENT_STATE_HOVER)) {
+ EventStateManager* esm = PresContext()->EventStateManager();
+ esm->SetContentState(nullptr, NS_EVENT_STATE_HOVER);
+ }
+
+ nsMenuFrame* menuFrame = do_QueryFrame(GetParent());
+ if (menuFrame) {
+ menuFrame->PopupClosed(aDeselectMenu);
+ }
+}
+
+uint32_t
+nsMenuPopupFrame::GetXULLayoutFlags()
+{
+ return NS_FRAME_NO_SIZE_VIEW | NS_FRAME_NO_MOVE_VIEW | NS_FRAME_NO_VISIBILITY;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GetRootViewForPopup
+// Retrieves the view for the popup widget that contains the given frame.
+// If the given frame is not contained by a popup widget, return the
+// root view of the root viewmanager.
+nsView*
+nsMenuPopupFrame::GetRootViewForPopup(nsIFrame* aStartFrame)
+{
+ nsView* view = aStartFrame->GetClosestView();
+ NS_ASSERTION(view, "frame must have a closest view!");
+ while (view) {
+ // Walk up the view hierarchy looking for a view whose widget has a
+ // window type of eWindowType_popup - in other words a popup window
+ // widget. If we find one, this is the view we want.
+ nsIWidget* widget = view->GetWidget();
+ if (widget && widget->WindowType() == eWindowType_popup) {
+ return view;
+ }
+
+ nsView* temp = view->GetParent();
+ if (!temp) {
+ // Otherwise, we've walked all the way up to the root view and not
+ // found a view for a popup window widget. Just return the root view.
+ return view;
+ }
+ view = temp;
+ }
+
+ return nullptr;
+}
+
+nsPoint
+nsMenuPopupFrame::AdjustPositionForAnchorAlign(nsRect& anchorRect,
+ FlipStyle& aHFlip, FlipStyle& aVFlip)
+{
+ // flip the anchor and alignment for right-to-left
+ int8_t popupAnchor(mPopupAnchor);
+ int8_t popupAlign(mPopupAlignment);
+ if (IsDirectionRTL()) {
+ // no need to flip the centered anchor types vertically
+ if (popupAnchor <= POPUPALIGNMENT_LEFTCENTER) {
+ popupAnchor = -popupAnchor;
+ }
+ popupAlign = -popupAlign;
+ }
+
+ nsRect originalAnchorRect(anchorRect);
+
+ // first, determine at which corner of the anchor the popup should appear
+ nsPoint pnt;
+ switch (popupAnchor) {
+ case POPUPALIGNMENT_LEFTCENTER:
+ pnt = nsPoint(anchorRect.x, anchorRect.y + anchorRect.height / 2);
+ anchorRect.y = pnt.y;
+ anchorRect.height = 0;
+ break;
+ case POPUPALIGNMENT_RIGHTCENTER:
+ pnt = nsPoint(anchorRect.XMost(), anchorRect.y + anchorRect.height / 2);
+ anchorRect.y = pnt.y;
+ anchorRect.height = 0;
+ break;
+ case POPUPALIGNMENT_TOPCENTER:
+ pnt = nsPoint(anchorRect.x + anchorRect.width / 2, anchorRect.y);
+ anchorRect.x = pnt.x;
+ anchorRect.width = 0;
+ break;
+ case POPUPALIGNMENT_BOTTOMCENTER:
+ pnt = nsPoint(anchorRect.x + anchorRect.width / 2, anchorRect.YMost());
+ anchorRect.x = pnt.x;
+ anchorRect.width = 0;
+ break;
+ case POPUPALIGNMENT_TOPRIGHT:
+ pnt = anchorRect.TopRight();
+ break;
+ case POPUPALIGNMENT_BOTTOMLEFT:
+ pnt = anchorRect.BottomLeft();
+ break;
+ case POPUPALIGNMENT_BOTTOMRIGHT:
+ pnt = anchorRect.BottomRight();
+ break;
+ case POPUPALIGNMENT_TOPLEFT:
+ default:
+ pnt = anchorRect.TopLeft();
+ break;
+ }
+
+ // If the alignment is on the right edge of the popup, move the popup left
+ // by the width. Similarly, if the alignment is on the bottom edge of the
+ // popup, move the popup up by the height. In addition, account for the
+ // margins of the popup on the edge on which it is aligned.
+ nsMargin margin(0, 0, 0, 0);
+ StyleMargin()->GetMargin(margin);
+ switch (popupAlign) {
+ case POPUPALIGNMENT_TOPRIGHT:
+ pnt.MoveBy(-mRect.width - margin.right, margin.top);
+ break;
+ case POPUPALIGNMENT_BOTTOMLEFT:
+ pnt.MoveBy(margin.left, -mRect.height - margin.bottom);
+ break;
+ case POPUPALIGNMENT_BOTTOMRIGHT:
+ pnt.MoveBy(-mRect.width - margin.right, -mRect.height - margin.bottom);
+ break;
+ case POPUPALIGNMENT_TOPLEFT:
+ default:
+ pnt.MoveBy(margin.left, margin.top);
+ break;
+ }
+
+ // If we aligning to the selected item in the popup, adjust the vertical
+ // position by the height of the menulist label and the selected item's
+ // position.
+ if (mPosition == POPUPPOSITION_SELECTION) {
+ MOZ_ASSERT(popupAnchor == POPUPALIGNMENT_BOTTOMLEFT ||
+ popupAnchor == POPUPALIGNMENT_BOTTOMRIGHT);
+ MOZ_ASSERT(popupAlign == POPUPALIGNMENT_TOPLEFT ||
+ popupAlign == POPUPALIGNMENT_TOPRIGHT);
+
+ nsIFrame* selectedItemFrame = GetSelectedItemForAlignment();
+ if (selectedItemFrame) {
+ pnt.y -= originalAnchorRect.height + selectedItemFrame->GetRect().y;
+ }
+ }
+
+ // Flipping horizontally is allowed as long as the popup is above or below
+ // the anchor. This will happen if both the anchor and alignment are top or
+ // both are bottom, but different values. Similarly, flipping vertically is
+ // allowed if the popup is to the left or right of the anchor. In this case,
+ // the values of the constants are such that both must be positive or both
+ // must be negative. A special case, used for overlap, allows flipping
+ // vertically as well.
+ // If we are flipping in both directions, we want to set a flip style both
+ // horizontally and vertically. However, we want to flip on the inside edge
+ // of the anchor. Consider the example of a typical dropdown menu.
+ // Vertically, we flip the popup on the outside edges of the anchor menu,
+ // however horizontally, we want to to use the inside edges so the popup
+ // still appears underneath the anchor menu instead of floating off the
+ // side of the menu.
+ switch (popupAnchor) {
+ case POPUPALIGNMENT_LEFTCENTER:
+ case POPUPALIGNMENT_RIGHTCENTER:
+ aHFlip = FlipStyle_Outside;
+ aVFlip = FlipStyle_Inside;
+ break;
+ case POPUPALIGNMENT_TOPCENTER:
+ case POPUPALIGNMENT_BOTTOMCENTER:
+ aHFlip = FlipStyle_Inside;
+ aVFlip = FlipStyle_Outside;
+ break;
+ default:
+ {
+ FlipStyle anchorEdge = mFlip == FlipType_Both ? FlipStyle_Inside : FlipStyle_None;
+ aHFlip = (popupAnchor == -popupAlign) ? FlipStyle_Outside : anchorEdge;
+ if (((popupAnchor > 0) == (popupAlign > 0)) ||
+ (popupAnchor == POPUPALIGNMENT_TOPLEFT && popupAlign == POPUPALIGNMENT_TOPLEFT))
+ aVFlip = FlipStyle_Outside;
+ else
+ aVFlip = anchorEdge;
+ break;
+ }
+ }
+
+ return pnt;
+}
+
+nsIFrame* nsMenuPopupFrame::GetSelectedItemForAlignment()
+{
+ // This method adjusts a menulist's popup such that the selected item is under the cursor, aligned
+ // with the menulist label.
+ nsCOMPtr<nsIDOMXULSelectControlElement> select = do_QueryInterface(mAnchorContent);
+ if (!select) {
+ // If there isn't an anchor, then try just getting the parent of the popup.
+ select = do_QueryInterface(mContent->GetParent());
+ if (!select) {
+ return nullptr;
+ }
+ }
+
+ nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
+ select->GetSelectedItem(getter_AddRefs(item));
+
+ nsCOMPtr<nsIContent> selectedElement = do_QueryInterface(item);
+ return selectedElement ? selectedElement->GetPrimaryFrame() : nullptr;
+}
+
+nscoord
+nsMenuPopupFrame::SlideOrResize(nscoord& aScreenPoint, nscoord aSize,
+ nscoord aScreenBegin, nscoord aScreenEnd,
+ nscoord *aOffset)
+{
+ // The popup may be positioned such that either the left/top or bottom/right
+ // is outside the screen - but never both.
+ nscoord newPos =
+ std::max(aScreenBegin, std::min(aScreenEnd - aSize, aScreenPoint));
+ *aOffset = newPos - aScreenPoint;
+ aScreenPoint = newPos;
+ return std::min(aSize, aScreenEnd - aScreenPoint);
+}
+
+nscoord
+nsMenuPopupFrame::FlipOrResize(nscoord& aScreenPoint, nscoord aSize,
+ nscoord aScreenBegin, nscoord aScreenEnd,
+ nscoord aAnchorBegin, nscoord aAnchorEnd,
+ nscoord aMarginBegin, nscoord aMarginEnd,
+ nscoord aOffsetForContextMenu, FlipStyle aFlip,
+ bool aEndAligned, bool* aFlipSide)
+{
+ // The flip side argument will be set to true if there wasn't room and we
+ // flipped to the opposite side.
+ *aFlipSide = false;
+
+ // all of the coordinates used here are in app units relative to the screen
+ nscoord popupSize = aSize;
+ if (aScreenPoint < aScreenBegin) {
+ // at its current position, the popup would extend past the left or top
+ // edge of the screen, so it will have to be moved or resized.
+ if (aFlip) {
+ // for inside flips, we flip on the opposite side of the anchor
+ nscoord startpos = aFlip == FlipStyle_Outside ? aAnchorBegin : aAnchorEnd;
+ nscoord endpos = aFlip == FlipStyle_Outside ? aAnchorEnd : aAnchorBegin;
+
+ // check whether there is more room to the left and right (or top and
+ // bottom) of the anchor and put the popup on the side with more room.
+ if (startpos - aScreenBegin >= aScreenEnd - endpos) {
+ aScreenPoint = aScreenBegin;
+ popupSize = startpos - aScreenPoint - aMarginEnd;
+ *aFlipSide = !aEndAligned;
+ }
+ else {
+ // If the newly calculated position is different than the existing
+ // position, flip such that the popup is to the right or bottom of the
+ // anchor point instead . However, when flipping use the same margin
+ // size.
+ nscoord newScreenPoint = endpos + aMarginEnd;
+ if (newScreenPoint != aScreenPoint) {
+ *aFlipSide = aEndAligned;
+ aScreenPoint = newScreenPoint;
+ // check if the new position is still off the right or bottom edge of
+ // the screen. If so, resize the popup.
+ if (aScreenPoint + aSize > aScreenEnd) {
+ popupSize = aScreenEnd - aScreenPoint;
+ }
+ }
+ }
+ }
+ else {
+ aScreenPoint = aScreenBegin;
+ }
+ }
+ else if (aScreenPoint + aSize > aScreenEnd) {
+ // at its current position, the popup would extend past the right or
+ // bottom edge of the screen, so it will have to be moved or resized.
+ if (aFlip) {
+ // for inside flips, we flip on the opposite side of the anchor
+ nscoord startpos = aFlip == FlipStyle_Outside ? aAnchorBegin : aAnchorEnd;
+ nscoord endpos = aFlip == FlipStyle_Outside ? aAnchorEnd : aAnchorBegin;
+
+ // check whether there is more room to the left and right (or top and
+ // bottom) of the anchor and put the popup on the side with more room.
+ if (aScreenEnd - endpos >= startpos - aScreenBegin) {
+ *aFlipSide = aEndAligned;
+ if (mIsContextMenu) {
+ aScreenPoint = aScreenEnd - aSize;
+ }
+ else {
+ aScreenPoint = endpos + aMarginBegin;
+ popupSize = aScreenEnd - aScreenPoint;
+ }
+ }
+ else {
+ // if the newly calculated position is different than the existing
+ // position, we flip such that the popup is to the left or top of the
+ // anchor point instead.
+ nscoord newScreenPoint = startpos - aSize - aMarginBegin - std::max(aOffsetForContextMenu, 0);
+ if (newScreenPoint != aScreenPoint) {
+ *aFlipSide = !aEndAligned;
+ aScreenPoint = newScreenPoint;
+
+ // check if the new position is still off the left or top edge of the
+ // screen. If so, resize the popup.
+ if (aScreenPoint < aScreenBegin) {
+ aScreenPoint = aScreenBegin;
+ if (!mIsContextMenu) {
+ popupSize = startpos - aScreenPoint - aMarginBegin;
+ }
+ }
+ }
+ }
+ }
+ else {
+ aScreenPoint = aScreenEnd - aSize;
+ }
+ }
+
+ // Make sure that the point is within the screen boundaries and that the
+ // size isn't off the edge of the screen. This can happen when a large
+ // positive or negative margin is used.
+ if (aScreenPoint < aScreenBegin) {
+ aScreenPoint = aScreenBegin;
+ }
+ if (aScreenPoint > aScreenEnd) {
+ aScreenPoint = aScreenEnd - aSize;
+ }
+
+ // If popupSize ended up being negative, or the original size was actually
+ // smaller than the calculated popup size, just use the original size instead.
+ if (popupSize <= 0 || aSize < popupSize) {
+ popupSize = aSize;
+ }
+ return std::min(popupSize, aScreenEnd - aScreenPoint);
+}
+
+nsresult
+nsMenuPopupFrame::SetPopupPosition(nsIFrame* aAnchorFrame, bool aIsMove, bool aSizedToPopup, bool aNotify)
+{
+ if (!mShouldAutoPosition)
+ return NS_OK;
+
+ // If this is due to a move, return early if the popup hasn't been laid out
+ // yet. On Windows, this can happen when using a drag popup before it opens.
+ if (aIsMove && (mPrefSize.width == -1 || mPrefSize.height == -1)) {
+ return NS_OK;
+ }
+
+ nsPresContext* presContext = PresContext();
+ nsIFrame* rootFrame = presContext->PresShell()->FrameManager()->GetRootFrame();
+ NS_ASSERTION(rootFrame->GetView() && GetView() &&
+ rootFrame->GetView() == GetView()->GetParent(),
+ "rootFrame's view is not our view's parent???");
+
+ // For anchored popups, the anchor rectangle. For non-anchored popups, the
+ // size will be 0.
+ nsRect anchorRect;
+
+ // Width of the parent, used when aSizedToPopup is true.
+ int32_t parentWidth = 0;
+
+ bool anchored = IsAnchored();
+ if (anchored || aSizedToPopup) {
+ // In order to deal with transforms, we need the root prescontext:
+ nsPresContext* rootPresContext = presContext->GetRootPresContext();
+
+ // If we can't reach a root pres context, don't bother continuing:
+ if (!rootPresContext) {
+ return NS_OK;
+ }
+
+ // If anchored to a rectangle, use that rectangle. Otherwise, determine the
+ // rectangle from the anchor.
+ if (mAnchorType == MenuPopupAnchorType_Rect) {
+ anchorRect = ToAppUnits(mScreenRect, presContext->AppUnitsPerCSSPixel());
+ }
+ else {
+ // if the frame is not specified, use the anchor node passed to OpenPopup. If
+ // that wasn't specified either, use the root frame. Note that mAnchorContent
+ // might be a different document so its presshell must be used.
+ if (!aAnchorFrame) {
+ if (mAnchorContent) {
+ aAnchorFrame = mAnchorContent->GetPrimaryFrame();
+ }
+
+ if (!aAnchorFrame) {
+ aAnchorFrame = rootFrame;
+ if (!aAnchorFrame)
+ return NS_OK;
+ }
+ }
+
+ // And then we need its root frame for a reference
+ nsIFrame* referenceFrame = rootPresContext->FrameManager()->GetRootFrame();
+
+ // the dimensions of the anchor
+ nsRect parentRect = aAnchorFrame->GetRectRelativeToSelf();
+ // Relative to the root
+ anchorRect = nsLayoutUtils::TransformFrameRectToAncestor(aAnchorFrame,
+ parentRect,
+ referenceFrame);
+ // Relative to the screen
+ anchorRect.MoveBy(referenceFrame->GetScreenRectInAppUnits().TopLeft());
+
+ // In its own app units
+ anchorRect =
+ anchorRect.ScaleToOtherAppUnitsRoundOut(rootPresContext->AppUnitsPerDevPixel(),
+ presContext->AppUnitsPerDevPixel());
+ }
+
+ // The width is needed when aSizedToPopup is true
+ parentWidth = anchorRect.width;
+ }
+
+ // Set the popup's size to the preferred size. Below, this size will be
+ // adjusted to fit on the screen or within the content area. If the anchor
+ // is sized to the popup, use the anchor's width instead of the preferred
+ // width. The preferred size should already be set by the parent frame.
+ NS_ASSERTION(mPrefSize.width >= 0 || mPrefSize.height >= 0,
+ "preferred size of popup not set");
+ mRect.width = aSizedToPopup ? parentWidth : mPrefSize.width;
+ mRect.height = mPrefSize.height;
+
+ // If we're anchoring to a rect, and the rect is smaller than the preferred size
+ // of the popup, change its width accordingly.
+ if (mAnchorType == MenuPopupAnchorType_Rect &&
+ parentWidth < mPrefSize.width) {
+ mRect.width = mPrefSize.width;
+ }
+
+ // the screen position in app units where the popup should appear
+ nsPoint screenPoint;
+
+ // indicators of whether the popup should be flipped or resized.
+ FlipStyle hFlip = FlipStyle_None, vFlip = FlipStyle_None;
+
+ nsMargin margin(0, 0, 0, 0);
+ StyleMargin()->GetMargin(margin);
+
+ // the screen rectangle of the root frame, in dev pixels.
+ nsRect rootScreenRect = rootFrame->GetScreenRectInAppUnits();
+
+ nsDeviceContext* devContext = presContext->DeviceContext();
+ nsPoint offsetForContextMenu;
+
+ bool isNoAutoHide = IsNoAutoHide();
+ nsPopupLevel popupLevel = PopupLevel(isNoAutoHide);
+
+ if (anchored) {
+ // if we are anchored, there are certain things we don't want to do when
+ // repositioning the popup to fit on the screen, such as end up positioned
+ // over the anchor, for instance a popup appearing over the menu label.
+ // When doing this reposition, we want to move the popup to the side with
+ // the most room. The combination of anchor and alignment dictate if we
+ // readjust above/below or to the left/right.
+ if (mAnchorContent || mAnchorType == MenuPopupAnchorType_Rect) {
+ // move the popup according to the anchor and alignment. This will also
+ // tell us which axis the popup is flush against in case we have to move
+ // it around later. The AdjustPositionForAnchorAlign method accounts for
+ // the popup's margin.
+ screenPoint = AdjustPositionForAnchorAlign(anchorRect, hFlip, vFlip);
+ }
+ else {
+ // with no anchor, the popup is positioned relative to the root frame
+ anchorRect = rootScreenRect;
+ screenPoint = anchorRect.TopLeft() + nsPoint(margin.left, margin.top);
+ }
+
+ // mXPos and mYPos specify an additonal offset passed to OpenPopup that
+ // should be added to the position. We also add the offset to the anchor
+ // pos so a later flip/resize takes the offset into account.
+ nscoord anchorXOffset = presContext->CSSPixelsToAppUnits(mXPos);
+ if (IsDirectionRTL()) {
+ screenPoint.x -= anchorXOffset;
+ anchorRect.x -= anchorXOffset;
+ } else {
+ screenPoint.x += anchorXOffset;
+ anchorRect.x += anchorXOffset;
+ }
+ nscoord anchorYOffset = presContext->CSSPixelsToAppUnits(mYPos);
+ screenPoint.y += anchorYOffset;
+ anchorRect.y += anchorYOffset;
+
+ // If this is a noautohide popup, set the screen coordinates of the popup.
+ // This way, the popup stays at the location where it was opened even when
+ // the window is moved. Popups at the parent level follow the parent
+ // window as it is moved and remained anchored, so we want to maintain the
+ // anchoring instead.
+ if (isNoAutoHide &&
+ (popupLevel != ePopupLevelParent || mAnchorType == MenuPopupAnchorType_Rect)) {
+ // Account for the margin that will end up being added to the screen coordinate
+ // the next time SetPopupPosition is called.
+ mAnchorType = MenuPopupAnchorType_Point;
+ mScreenRect.x = presContext->AppUnitsToIntCSSPixels(screenPoint.x - margin.left);
+ mScreenRect.y = presContext->AppUnitsToIntCSSPixels(screenPoint.y - margin.top);
+ }
+ }
+ else {
+ // The popup is positioned at a screen coordinate.
+ // First convert the screen position in mScreenRect from CSS pixels into
+ // device pixels, ignoring any zoom as mScreenRect holds unzoomed screen
+ // coordinates.
+ int32_t factor = devContext->AppUnitsPerDevPixelAtUnitFullZoom();
+
+ // Depending on the platform, context menus should be offset by varying amounts
+ // to ensure that they don't appear directly where the cursor is. Otherwise,
+ // it is too easy to have the context menu close up again.
+ if (mAdjustOffsetForContextMenu) {
+ nsPoint offsetForContextMenuDev;
+ offsetForContextMenuDev.x = nsPresContext::CSSPixelsToAppUnits(LookAndFeel::GetInt(
+ LookAndFeel::eIntID_ContextMenuOffsetHorizontal)) / factor;
+ offsetForContextMenuDev.y = nsPresContext::CSSPixelsToAppUnits(LookAndFeel::GetInt(
+ LookAndFeel::eIntID_ContextMenuOffsetVertical)) / factor;
+ offsetForContextMenu.x = presContext->DevPixelsToAppUnits(offsetForContextMenuDev.x);
+ offsetForContextMenu.y = presContext->DevPixelsToAppUnits(offsetForContextMenuDev.y);
+ }
+
+ // next, convert into app units accounting for the zoom
+ screenPoint.x = presContext->DevPixelsToAppUnits(
+ nsPresContext::CSSPixelsToAppUnits(mScreenRect.x) / factor);
+ screenPoint.y = presContext->DevPixelsToAppUnits(
+ nsPresContext::CSSPixelsToAppUnits(mScreenRect.y) / factor);
+ anchorRect = nsRect(screenPoint, nsSize(0, 0));
+
+ // add the margins on the popup
+ screenPoint.MoveBy(margin.left + offsetForContextMenu.x,
+ margin.top + offsetForContextMenu.y);
+
+#ifdef XP_MACOSX
+ // OSX tooltips follow standard flip rule but other popups flip horizontally not vertically
+ if (mPopupType == ePopupTypeTooltip) {
+ vFlip = FlipStyle_Outside;
+ } else {
+ hFlip = FlipStyle_Outside;
+ }
+#else
+ // Other OS screen positioned popups can be flipped vertically but never horizontally
+ vFlip = FlipStyle_Outside;
+#endif // #ifdef XP_MACOSX
+ }
+
+ // If a panel is being moved or has flip="none", don't constrain or flip it. But always do this for
+ // content shells, so that the popup doesn't extend outside the containing frame.
+ if (mInContentShell || (mFlip != FlipType_None &&
+ (!aIsMove || mPopupType != ePopupTypePanel))) {
+ int32_t appPerDev = presContext->AppUnitsPerDevPixel();
+ LayoutDeviceIntRect anchorRectDevPix =
+ LayoutDeviceIntRect::FromAppUnitsToNearest(anchorRect, appPerDev);
+ LayoutDeviceIntRect rootScreenRectDevPix =
+ LayoutDeviceIntRect::FromAppUnitsToNearest(rootScreenRect, appPerDev);
+ LayoutDeviceIntRect screenRectDevPix =
+ GetConstraintRect(anchorRectDevPix, rootScreenRectDevPix, popupLevel);
+ nsRect screenRect =
+ LayoutDeviceIntRect::ToAppUnits(screenRectDevPix, appPerDev);
+
+ // Ensure that anchorRect is on screen.
+ anchorRect = anchorRect.Intersect(screenRect);
+
+ // shrink the the popup down if it is larger than the screen size
+ if (mRect.width > screenRect.width)
+ mRect.width = screenRect.width;
+ if (mRect.height > screenRect.height)
+ mRect.height = screenRect.height;
+
+ // at this point the anchor (anchorRect) is within the available screen
+ // area (screenRect) and the popup is known to be no larger than the screen.
+
+ // We might want to "slide" an arrow if the panel is of the correct type -
+ // but we can only slide on one axis - the other axis must be "flipped or
+ // resized" as normal.
+ bool slideHorizontal = false, slideVertical = false;
+ if (mFlip == FlipType_Slide) {
+ int8_t position = GetAlignmentPosition();
+ slideHorizontal = position >= POPUPPOSITION_BEFORESTART &&
+ position <= POPUPPOSITION_AFTEREND;
+ slideVertical = position >= POPUPPOSITION_STARTBEFORE &&
+ position <= POPUPPOSITION_ENDAFTER;
+ }
+
+ // Next, check if there is enough space to show the popup at full size when
+ // positioned at screenPoint. If not, flip the popups to the opposite side
+ // of their anchor point, or resize them as necessary.
+ bool endAligned = IsDirectionRTL() ?
+ mPopupAlignment == POPUPALIGNMENT_TOPLEFT || mPopupAlignment == POPUPALIGNMENT_BOTTOMLEFT :
+ mPopupAlignment == POPUPALIGNMENT_TOPRIGHT || mPopupAlignment == POPUPALIGNMENT_BOTTOMRIGHT;
+ if (slideHorizontal) {
+ mRect.width = SlideOrResize(screenPoint.x, mRect.width, screenRect.x,
+ screenRect.XMost(), &mAlignmentOffset);
+ } else {
+ mRect.width = FlipOrResize(screenPoint.x, mRect.width, screenRect.x,
+ screenRect.XMost(), anchorRect.x, anchorRect.XMost(),
+ margin.left, margin.right, offsetForContextMenu.x, hFlip,
+ endAligned, &mHFlip);
+ }
+
+ endAligned = mPopupAlignment == POPUPALIGNMENT_BOTTOMLEFT ||
+ mPopupAlignment == POPUPALIGNMENT_BOTTOMRIGHT;
+ if (slideVertical) {
+ mRect.height = SlideOrResize(screenPoint.y, mRect.height, screenRect.y,
+ screenRect.YMost(), &mAlignmentOffset);
+ } else {
+ mRect.height = FlipOrResize(screenPoint.y, mRect.height, screenRect.y,
+ screenRect.YMost(), anchorRect.y, anchorRect.YMost(),
+ margin.top, margin.bottom, offsetForContextMenu.y, vFlip,
+ endAligned, &mVFlip);
+ }
+
+ NS_ASSERTION(screenPoint.x >= screenRect.x && screenPoint.y >= screenRect.y &&
+ screenPoint.x + mRect.width <= screenRect.XMost() &&
+ screenPoint.y + mRect.height <= screenRect.YMost(),
+ "Popup is offscreen");
+ }
+
+ // snap the popup's position in screen coordinates to device pixels,
+ // see bug 622507, bug 961431
+ screenPoint.x = presContext->RoundAppUnitsToNearestDevPixels(screenPoint.x);
+ screenPoint.y = presContext->RoundAppUnitsToNearestDevPixels(screenPoint.y);
+
+ // determine the x and y position of the view by subtracting the desired
+ // screen position from the screen position of the root frame.
+ nsPoint viewPoint = screenPoint - rootScreenRect.TopLeft();
+
+ nsView* view = GetView();
+ NS_ASSERTION(view, "popup with no view");
+
+ // Offset the position by the width and height of the borders and titlebar.
+ // Even though GetClientOffset should return (0, 0) when there is no
+ // titlebar or borders, we skip these calculations anyway for non-panels
+ // to save time since they will never have a titlebar.
+ nsIWidget* widget = view->GetWidget();
+ if (mPopupType == ePopupTypePanel && widget) {
+ mLastClientOffset = widget->GetClientOffset();
+ viewPoint.x += presContext->DevPixelsToAppUnits(mLastClientOffset.x);
+ viewPoint.y += presContext->DevPixelsToAppUnits(mLastClientOffset.y);
+ }
+
+ presContext->GetPresShell()->GetViewManager()->
+ MoveViewTo(view, viewPoint.x, viewPoint.y);
+
+ // Now that we've positioned the view, sync up the frame's origin.
+ nsBoxFrame::SetPosition(viewPoint - GetParent()->GetOffsetTo(rootFrame));
+
+ if (aSizedToPopup) {
+ nsBoxLayoutState state(PresContext());
+ // XXXndeakin can parentSize.width still extend outside?
+ SetXULBounds(state, mRect);
+ }
+
+ // If the popup is in the positioned state or if it is shown and the position
+ // or size changed, dispatch a popuppositioned event if the popup wants it.
+ nsIntRect newRect(screenPoint.x, screenPoint.y, mRect.width, mRect.height);
+ if (mPopupState == ePopupPositioning ||
+ (mPopupState == ePopupShown && !newRect.IsEqualEdges(mUsedScreenRect))) {
+ mUsedScreenRect = newRect;
+ if (aNotify) {
+ nsXULPopupPositionedEvent::DispatchIfNeeded(mContent, false, false);
+ }
+ }
+
+ return NS_OK;
+}
+
+/* virtual */ nsMenuFrame*
+nsMenuPopupFrame::GetCurrentMenuItem()
+{
+ return mCurrentMenu;
+}
+
+LayoutDeviceIntRect
+nsMenuPopupFrame::GetConstraintRect(const LayoutDeviceIntRect& aAnchorRect,
+ const LayoutDeviceIntRect& aRootScreenRect,
+ nsPopupLevel aPopupLevel)
+{
+ LayoutDeviceIntRect screenRectPixels;
+
+ // determine the available screen space. It will be reduced by the OS chrome
+ // such as menubars. It addition, for content shells, it will be the area of
+ // the content rather than the screen.
+ nsCOMPtr<nsIScreen> screen;
+ nsCOMPtr<nsIScreenManager> sm(do_GetService("@mozilla.org/gfx/screenmanager;1"));
+ if (sm) {
+ // for content shells, get the screen where the root frame is located.
+ // This is because we need to constrain the content to this content area,
+ // so we should use the same screen. Otherwise, use the screen where the
+ // anchor is located.
+ DesktopToLayoutDeviceScale scale =
+ PresContext()->DeviceContext()->GetDesktopToDeviceScale();
+ DesktopRect rect =
+ (mInContentShell ? aRootScreenRect : aAnchorRect) / scale;
+ int32_t width = std::max(1, NSToIntRound(rect.width));
+ int32_t height = std::max(1, NSToIntRound(rect.height));
+ sm->ScreenForRect(rect.x, rect.y, width, height, getter_AddRefs(screen));
+ if (screen) {
+ // Non-top-level popups (which will always be panels)
+ // should never overlap the OS bar:
+ bool dontOverlapOSBar = aPopupLevel != ePopupLevelTop;
+ // get the total screen area if the popup is allowed to overlap it.
+ if (!dontOverlapOSBar && mMenuCanOverlapOSBar && !mInContentShell)
+ screen->GetRect(&screenRectPixels.x, &screenRectPixels.y,
+ &screenRectPixels.width, &screenRectPixels.height);
+ else
+ screen->GetAvailRect(&screenRectPixels.x, &screenRectPixels.y,
+ &screenRectPixels.width, &screenRectPixels.height);
+ }
+ }
+
+ if (mInContentShell) {
+ // for content shells, clip to the client area rather than the screen area
+ screenRectPixels.IntersectRect(screenRectPixels, aRootScreenRect);
+ }
+ else if (!mOverrideConstraintRect.IsEmpty()) {
+ LayoutDeviceIntRect overrideConstrainRect =
+ LayoutDeviceIntRect::FromAppUnitsToNearest(mOverrideConstraintRect,
+ PresContext()->AppUnitsPerDevPixel());
+ // This is currently only used for <select> elements where we want to constrain
+ // vertically to the screen but not horizontally, so do the intersection and then
+ // reset the horizontal values.
+ screenRectPixels.IntersectRect(screenRectPixels, overrideConstrainRect);
+ screenRectPixels.x = overrideConstrainRect.x;
+ screenRectPixels.width = overrideConstrainRect.width;
+ }
+
+ return screenRectPixels;
+}
+
+void nsMenuPopupFrame::CanAdjustEdges(int8_t aHorizontalSide,
+ int8_t aVerticalSide,
+ LayoutDeviceIntPoint& aChange)
+{
+ int8_t popupAlign(mPopupAlignment);
+ if (IsDirectionRTL()) {
+ popupAlign = -popupAlign;
+ }
+
+ if (aHorizontalSide == (mHFlip ? NS_SIDE_RIGHT : NS_SIDE_LEFT)) {
+ if (popupAlign == POPUPALIGNMENT_TOPLEFT || popupAlign == POPUPALIGNMENT_BOTTOMLEFT) {
+ aChange.x = 0;
+ }
+ }
+ else if (aHorizontalSide == (mHFlip ? NS_SIDE_LEFT : NS_SIDE_RIGHT)) {
+ if (popupAlign == POPUPALIGNMENT_TOPRIGHT || popupAlign == POPUPALIGNMENT_BOTTOMRIGHT) {
+ aChange.x = 0;
+ }
+ }
+
+ if (aVerticalSide == (mVFlip ? NS_SIDE_BOTTOM : NS_SIDE_TOP)) {
+ if (popupAlign == POPUPALIGNMENT_TOPLEFT || popupAlign == POPUPALIGNMENT_TOPRIGHT) {
+ aChange.y = 0;
+ }
+ }
+ else if (aVerticalSide == (mVFlip ? NS_SIDE_TOP : NS_SIDE_BOTTOM)) {
+ if (popupAlign == POPUPALIGNMENT_BOTTOMLEFT || popupAlign == POPUPALIGNMENT_BOTTOMRIGHT) {
+ aChange.y = 0;
+ }
+ }
+}
+
+ConsumeOutsideClicksResult nsMenuPopupFrame::ConsumeOutsideClicks()
+{
+ // If the popup has explicitly set a consume mode, honor that.
+ if (mConsumeRollupEvent != PopupBoxObject::ROLLUP_DEFAULT) {
+ return (mConsumeRollupEvent == PopupBoxObject::ROLLUP_CONSUME) ?
+ ConsumeOutsideClicks_True : ConsumeOutsideClicks_ParentOnly;
+ }
+
+ if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::consumeoutsideclicks,
+ nsGkAtoms::_true, eCaseMatters)) {
+ return ConsumeOutsideClicks_True;
+ }
+ if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::consumeoutsideclicks,
+ nsGkAtoms::_false, eCaseMatters)) {
+ return ConsumeOutsideClicks_ParentOnly;
+ }
+ if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::consumeoutsideclicks,
+ nsGkAtoms::never, eCaseMatters)) {
+ return ConsumeOutsideClicks_Never;
+ }
+
+ nsCOMPtr<nsIContent> parentContent = mContent->GetParent();
+ if (parentContent) {
+ dom::NodeInfo *ni = parentContent->NodeInfo();
+ if (ni->Equals(nsGkAtoms::menulist, kNameSpaceID_XUL)) {
+ return ConsumeOutsideClicks_True; // Consume outside clicks for combo boxes on all platforms
+ }
+#if defined(XP_WIN)
+ // Don't consume outside clicks for menus in Windows
+ if (ni->Equals(nsGkAtoms::menu, kNameSpaceID_XUL) ||
+ ni->Equals(nsGkAtoms::splitmenu, kNameSpaceID_XUL) ||
+ ni->Equals(nsGkAtoms::popupset, kNameSpaceID_XUL) ||
+ ((ni->Equals(nsGkAtoms::button, kNameSpaceID_XUL) ||
+ ni->Equals(nsGkAtoms::toolbarbutton, kNameSpaceID_XUL)) &&
+ (parentContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+ nsGkAtoms::menu, eCaseMatters) ||
+ parentContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+ nsGkAtoms::menuButton, eCaseMatters)))) {
+ return ConsumeOutsideClicks_Never;
+ }
+#endif
+ if (ni->Equals(nsGkAtoms::textbox, kNameSpaceID_XUL)) {
+ // Don't consume outside clicks for autocomplete widget
+ if (parentContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+ nsGkAtoms::autocomplete, eCaseMatters)) {
+ return ConsumeOutsideClicks_Never;
+ }
+ }
+ }
+
+ return ConsumeOutsideClicks_True;
+}
+
+// XXXroc this is megalame. Fossicking around for a frame of the right
+// type is a recipe for disaster in the long term.
+nsIScrollableFrame* nsMenuPopupFrame::GetScrollFrame(nsIFrame* aStart)
+{
+ if (!aStart)
+ return nullptr;
+
+ // try start frame and siblings
+ nsIFrame* currFrame = aStart;
+ do {
+ nsIScrollableFrame* sf = do_QueryFrame(currFrame);
+ if (sf)
+ return sf;
+ currFrame = currFrame->GetNextSibling();
+ } while (currFrame);
+
+ // try children
+ currFrame = aStart;
+ do {
+ nsIFrame* childFrame = currFrame->PrincipalChildList().FirstChild();
+ nsIScrollableFrame* sf = GetScrollFrame(childFrame);
+ if (sf)
+ return sf;
+ currFrame = currFrame->GetNextSibling();
+ } while (currFrame);
+
+ return nullptr;
+}
+
+void nsMenuPopupFrame::EnsureMenuItemIsVisible(nsMenuFrame* aMenuItem)
+{
+ if (aMenuItem) {
+ aMenuItem->PresContext()->PresShell()->ScrollFrameRectIntoView(
+ aMenuItem,
+ nsRect(nsPoint(0,0), aMenuItem->GetRect().Size()),
+ nsIPresShell::ScrollAxis(),
+ nsIPresShell::ScrollAxis(),
+ nsIPresShell::SCROLL_OVERFLOW_HIDDEN |
+ nsIPresShell::SCROLL_FIRST_ANCESTOR_ONLY);
+ }
+}
+
+void nsMenuPopupFrame::ChangeByPage(bool aIsUp)
+{
+ // Only scroll by page within menulists.
+ if (!IsMenuList()) {
+ return;
+ }
+
+ nsMenuFrame* newMenu = nullptr;
+ nsIFrame* currentMenu = mCurrentMenu;
+ if (!currentMenu) {
+ // If there is no current menu item, get the first item. When moving up,
+ // just use this as the newMenu and leave currentMenu null so that no
+ // check for a later element is performed. When moving down, set currentMenu
+ // so that we look for one page down from the first item.
+ newMenu = nsXULPopupManager::GetNextMenuItem(this, nullptr, true);
+ if (!aIsUp) {
+ currentMenu = newMenu;
+ }
+ }
+
+ if (currentMenu) {
+ nscoord scrollHeight = mRect.height;
+ nsIScrollableFrame *scrollframe = GetScrollFrame(this);
+ if (scrollframe) {
+ scrollHeight = scrollframe->GetScrollPortRect().height;
+ }
+
+ // Get the position of the current item and add or subtract one popup's
+ // height to or from it.
+ nscoord targetPosition = aIsUp ? currentMenu->GetRect().YMost() - scrollHeight :
+ currentMenu->GetRect().y + scrollHeight;
+
+ // Indicates that the last visible child was a valid menuitem.
+ bool lastWasValid = false;
+
+ // Look for the next child which is just past the target position. This child
+ // will need to be selected.
+ while (currentMenu) {
+ // Only consider menu frames.
+ nsMenuFrame* menuFrame = do_QueryFrame(currentMenu);
+ if (menuFrame &&
+ nsXULPopupManager::IsValidMenuItem(menuFrame->GetContent(), true)) {
+
+ // If the right position was found, break out. Otherwise, look for another item.
+ if ((!aIsUp && currentMenu->GetRect().YMost() > targetPosition) ||
+ (aIsUp && currentMenu->GetRect().y < targetPosition)) {
+
+ // If the last visible child was not a valid menuitem or was disabled,
+ // use this as the menu to select, skipping over any non-valid items at
+ // the edge of the page.
+ if (!lastWasValid) {
+ newMenu = menuFrame;
+ }
+
+ break;
+ }
+
+ // Assign this item to newMenu. This item will be selected in case we
+ // don't find any more.
+ lastWasValid = true;
+ newMenu = menuFrame;
+ }
+ else {
+ lastWasValid = false;
+ }
+
+ currentMenu = aIsUp ? currentMenu->GetPrevSibling() :
+ currentMenu->GetNextSibling();
+ }
+ }
+
+ // Select the new menuitem.
+ if (newMenu) {
+ ChangeMenuItem(newMenu, false, true);
+ }
+}
+
+NS_IMETHODIMP nsMenuPopupFrame::SetCurrentMenuItem(nsMenuFrame* aMenuItem)
+{
+ if (mCurrentMenu == aMenuItem)
+ return NS_OK;
+
+ if (mCurrentMenu) {
+ mCurrentMenu->SelectMenu(false);
+ }
+
+ if (aMenuItem) {
+ EnsureMenuItemIsVisible(aMenuItem);
+ aMenuItem->SelectMenu(true);
+ }
+
+ mCurrentMenu = aMenuItem;
+
+ return NS_OK;
+}
+
+void
+nsMenuPopupFrame::CurrentMenuIsBeingDestroyed()
+{
+ mCurrentMenu = nullptr;
+}
+
+NS_IMETHODIMP
+nsMenuPopupFrame::ChangeMenuItem(nsMenuFrame* aMenuItem,
+ bool aSelectFirstItem,
+ bool aFromKey)
+{
+ if (mCurrentMenu == aMenuItem)
+ return NS_OK;
+
+ // When a context menu is open, the current menu is locked, and no change
+ // to the menu is allowed.
+ nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+ if (!mIsContextMenu && pm && pm->HasContextMenu(this))
+ return NS_OK;
+
+ // Unset the current child.
+ if (mCurrentMenu) {
+ mCurrentMenu->SelectMenu(false);
+ nsMenuPopupFrame* popup = mCurrentMenu->GetPopup();
+ if (popup) {
+ if (mCurrentMenu->IsOpen()) {
+ if (pm)
+ pm->HidePopupAfterDelay(popup);
+ }
+ }
+ }
+
+ // Set the new child.
+ if (aMenuItem) {
+ EnsureMenuItemIsVisible(aMenuItem);
+ aMenuItem->SelectMenu(true);
+
+ // On Windows, a menulist should update its value whenever navigation was
+ // done by the keyboard.
+#ifdef XP_WIN
+ if (aFromKey && IsOpen() && IsMenuList()) {
+ // Fire a command event as the new item, but we don't want to close
+ // the menu, blink it, or update any other state of the menuitem. The
+ // command event will cause the item to be selected.
+ nsContentUtils::DispatchXULCommand(aMenuItem->GetContent(), /* aTrusted = */ true,
+ nullptr, PresContext()->PresShell(),
+ false, false, false, false);
+ }
+#endif
+ }
+
+ mCurrentMenu = aMenuItem;
+
+ return NS_OK;
+}
+
+nsMenuFrame*
+nsMenuPopupFrame::Enter(WidgetGUIEvent* aEvent)
+{
+ mIncrementalString.Truncate();
+
+ // Give it to the child.
+ if (mCurrentMenu)
+ return mCurrentMenu->Enter(aEvent);
+
+ return nullptr;
+}
+
+nsMenuFrame*
+nsMenuPopupFrame::FindMenuWithShortcut(nsIDOMKeyEvent* aKeyEvent, bool& doAction)
+{
+ uint32_t charCode, keyCode;
+ aKeyEvent->GetCharCode(&charCode);
+ aKeyEvent->GetKeyCode(&keyCode);
+
+ doAction = false;
+
+ // Enumerate over our list of frames.
+ auto insertion = PresContext()->PresShell()->
+ FrameConstructor()->GetInsertionPoint(GetContent(), nullptr);
+ nsContainerFrame* immediateParent = insertion.mParentFrame;
+ if (!immediateParent)
+ immediateParent = this;
+
+ uint32_t matchCount = 0, matchShortcutCount = 0;
+ bool foundActive = false;
+ bool isShortcut;
+ nsMenuFrame* frameBefore = nullptr;
+ nsMenuFrame* frameAfter = nullptr;
+ nsMenuFrame* frameShortcut = nullptr;
+
+ nsIContent* parentContent = mContent->GetParent();
+
+ bool isMenu = parentContent &&
+ !parentContent->NodeInfo()->Equals(nsGkAtoms::menulist, kNameSpaceID_XUL);
+
+ DOMTimeStamp keyTime;
+ aKeyEvent->AsEvent()->GetTimeStamp(&keyTime);
+
+ if (charCode == 0) {
+ if (keyCode == nsIDOMKeyEvent::DOM_VK_BACK_SPACE) {
+ if (!isMenu && !mIncrementalString.IsEmpty()) {
+ mIncrementalString.SetLength(mIncrementalString.Length() - 1);
+ return nullptr;
+ }
+ else {
+#ifdef XP_WIN
+ nsCOMPtr<nsISound> soundInterface = do_CreateInstance("@mozilla.org/sound;1");
+ if (soundInterface)
+ soundInterface->Beep();
+#endif // #ifdef XP_WIN
+ }
+ }
+ return nullptr;
+ }
+ else {
+ char16_t uniChar = ToLowerCase(static_cast<char16_t>(charCode));
+ if (isMenu) {
+ // Menu supports only first-letter navigation
+ mIncrementalString = uniChar;
+ } else if (IsWithinIncrementalTime(keyTime)) {
+ mIncrementalString.Append(uniChar);
+ } else {
+ // Interval too long, treat as new typing
+ mIncrementalString = uniChar;
+ }
+ }
+
+ // See bug 188199 & 192346, if all letters in incremental string are same, just try to match the first one
+ nsAutoString incrementalString(mIncrementalString);
+ uint32_t charIndex = 1, stringLength = incrementalString.Length();
+ while (charIndex < stringLength && incrementalString[charIndex] == incrementalString[charIndex - 1]) {
+ charIndex++;
+ }
+ if (charIndex == stringLength) {
+ incrementalString.Truncate(1);
+ stringLength = 1;
+ }
+
+ sLastKeyTime = keyTime;
+
+ // NOTE: If you crashed here due to a bogus |immediateParent| it is
+ // possible that the menu whose shortcut is being looked up has
+ // been destroyed already. One strategy would be to
+ // setTimeout(<func>,0) as detailed in:
+ // <http://bugzilla.mozilla.org/show_bug.cgi?id=126675#c32>
+ nsIFrame* firstMenuItem = nsXULPopupManager::GetNextMenuItem(immediateParent, nullptr, true);
+ nsIFrame* currFrame = firstMenuItem;
+
+ int32_t menuAccessKey = -1;
+ nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
+
+ // We start searching from first child. This process is divided into two parts
+ // -- before current and after current -- by the current item
+ while (currFrame) {
+ nsIContent* current = currFrame->GetContent();
+ nsAutoString textKey;
+ if (menuAccessKey >= 0) {
+ // Get the shortcut attribute.
+ current->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, textKey);
+ }
+ if (textKey.IsEmpty()) { // No shortcut, try first letter
+ isShortcut = false;
+ current->GetAttr(kNameSpaceID_None, nsGkAtoms::label, textKey);
+ if (textKey.IsEmpty()) // No label, try another attribute (value)
+ current->GetAttr(kNameSpaceID_None, nsGkAtoms::value, textKey);
+ }
+ else
+ isShortcut = true;
+
+ if (StringBeginsWith(textKey, incrementalString,
+ nsCaseInsensitiveStringComparator())) {
+ // mIncrementalString is a prefix of textKey
+ nsMenuFrame* menu = do_QueryFrame(currFrame);
+ if (menu) {
+ // There is one match
+ matchCount++;
+ if (isShortcut) {
+ // There is one shortcut-key match
+ matchShortcutCount++;
+ // Record the matched item. If there is only one matched shortcut item, do it
+ frameShortcut = menu;
+ }
+ if (!foundActive) {
+ // It's a first candidate item located before/on the current item
+ if (!frameBefore)
+ frameBefore = menu;
+ }
+ else {
+ // It's a first candidate item located after the current item
+ if (!frameAfter)
+ frameAfter = menu;
+ }
+ }
+ else
+ return nullptr;
+ }
+
+ // Get the active status
+ if (current->AttrValueIs(kNameSpaceID_None, nsGkAtoms::menuactive,
+ nsGkAtoms::_true, eCaseMatters)) {
+ foundActive = true;
+ if (stringLength > 1) {
+ // If there is more than one char typed, the current item has highest priority,
+ // otherwise the item next to current has highest priority
+ if (currFrame == frameBefore)
+ return frameBefore;
+ }
+ }
+
+ nsMenuFrame* menu = do_QueryFrame(currFrame);
+ currFrame = nsXULPopupManager::GetNextMenuItem(immediateParent, menu, true);
+ if (currFrame == firstMenuItem)
+ break;
+ }
+
+ doAction = (isMenu && (matchCount == 1 || matchShortcutCount == 1));
+
+ if (matchShortcutCount == 1) // We have one matched shortcut item
+ return frameShortcut;
+ if (frameAfter) // If we have matched item after the current, use it
+ return frameAfter;
+ else if (frameBefore) // If we haven't, use the item before the current
+ return frameBefore;
+
+ // If we don't match anything, rollback the last typing
+ mIncrementalString.SetLength(mIncrementalString.Length() - 1);
+
+ // didn't find a matching menu item
+#ifdef XP_WIN
+ // behavior on Windows - this item is in a menu popup off of the
+ // menu bar, so beep and do nothing else
+ if (isMenu) {
+ nsCOMPtr<nsISound> soundInterface = do_CreateInstance("@mozilla.org/sound;1");
+ if (soundInterface)
+ soundInterface->Beep();
+ }
+#endif // #ifdef XP_WIN
+
+ return nullptr;
+}
+
+void
+nsMenuPopupFrame::LockMenuUntilClosed(bool aLock)
+{
+ mIsMenuLocked = aLock;
+
+ // Lock / unlock the parent, too.
+ nsMenuFrame* menu = do_QueryFrame(GetParent());
+ if (menu) {
+ nsMenuParent* parentParent = menu->GetMenuParent();
+ if (parentParent) {
+ parentParent->LockMenuUntilClosed(aLock);
+ }
+ }
+}
+
+nsIWidget*
+nsMenuPopupFrame::GetWidget()
+{
+ nsView * view = GetRootViewForPopup(this);
+ if (!view)
+ return nullptr;
+
+ return view->GetWidget();
+}
+
+void
+nsMenuPopupFrame::AttachedDismissalListener()
+{
+ mConsumeRollupEvent = PopupBoxObject::ROLLUP_DEFAULT;
+}
+
+// helpers /////////////////////////////////////////////////////////////
+
+nsresult
+nsMenuPopupFrame::AttributeChanged(int32_t aNameSpaceID,
+ nsIAtom* aAttribute,
+ int32_t aModType)
+
+{
+ nsresult rv = nsBoxFrame::AttributeChanged(aNameSpaceID, aAttribute,
+ aModType);
+
+ if (aAttribute == nsGkAtoms::left || aAttribute == nsGkAtoms::top)
+ MoveToAttributePosition();
+
+#ifndef MOZ_GTK2
+ if (aAttribute == nsGkAtoms::noautohide) {
+ nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+ if (pm)
+ pm->EnableRollup(mContent, !IsNoAutoHide());
+ }
+#endif
+
+ if (aAttribute == nsGkAtoms::label) {
+ // set the label for the titlebar
+ nsView* view = GetView();
+ if (view) {
+ nsIWidget* widget = view->GetWidget();
+ if (widget) {
+ nsAutoString title;
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, title);
+ if (!title.IsEmpty()) {
+ widget->SetTitle(title);
+ }
+ }
+ }
+ }
+
+ return rv;
+}
+
+void
+nsMenuPopupFrame::MoveToAttributePosition()
+{
+ // Move the widget around when the user sets the |left| and |top| attributes.
+ // Note that this is not the best way to move the widget, as it results in lots
+ // of FE notifications and is likely to be slow as molasses. Use |moveTo| on
+ // PopupBoxObject if possible.
+ nsAutoString left, top;
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::left, left);
+ mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::top, top);
+ nsresult err1, err2;
+ mozilla::CSSIntPoint pos(left.ToInteger(&err1), top.ToInteger(&err2));
+
+ if (NS_SUCCEEDED(err1) && NS_SUCCEEDED(err2))
+ MoveTo(pos, false);
+}
+
+void
+nsMenuPopupFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+ if (mReflowCallbackData.mPosted) {
+ PresContext()->PresShell()->CancelReflowCallback(this);
+ mReflowCallbackData.Clear();
+ }
+
+ nsMenuFrame* menu = do_QueryFrame(GetParent());
+ if (menu) {
+ // clear the open attribute on the parent menu
+ nsContentUtils::AddScriptRunner(
+ new nsUnsetAttrRunnable(menu->GetContent(), nsGkAtoms::open));
+ }
+
+ ClearPopupShownDispatcher();
+
+ nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+ if (pm)
+ pm->PopupDestroyed(this);
+
+ nsIRootBox* rootBox =
+ nsIRootBox::GetRootBox(PresContext()->GetPresShell());
+ if (rootBox && rootBox->GetDefaultTooltip() == mContent) {
+ rootBox->SetDefaultTooltip(nullptr);
+ }
+
+ nsBoxFrame::DestroyFrom(aDestructRoot);
+}
+
+
+void
+nsMenuPopupFrame::MoveTo(const CSSIntPoint& aPos, bool aUpdateAttrs)
+{
+ nsIWidget* widget = GetWidget();
+ if ((mScreenRect.x == aPos.x && mScreenRect.y == aPos.y) &&
+ (!widget || widget->GetClientOffset() == mLastClientOffset)) {
+ return;
+ }
+
+ // reposition the popup at the specified coordinates. Don't clear the anchor
+ // and position, because the popup can be reset to its anchor position by
+ // using (-1, -1) as coordinates. Subtract off the margin as it will be
+ // added to the position when SetPopupPosition is called.
+ nsMargin margin(0, 0, 0, 0);
+ StyleMargin()->GetMargin(margin);
+
+ // Workaround for bug 788189. See also bug 708278 comment #25 and following.
+ if (mAdjustOffsetForContextMenu) {
+ margin.left += nsPresContext::CSSPixelsToAppUnits(LookAndFeel::GetInt(
+ LookAndFeel::eIntID_ContextMenuOffsetHorizontal));
+ margin.top += nsPresContext::CSSPixelsToAppUnits(LookAndFeel::GetInt(
+ LookAndFeel::eIntID_ContextMenuOffsetVertical));
+ }
+
+ nsPresContext* presContext = PresContext();
+ mAnchorType = MenuPopupAnchorType_Point;
+ mScreenRect.x = aPos.x - presContext->AppUnitsToIntCSSPixels(margin.left);
+ mScreenRect.y = aPos.y - presContext->AppUnitsToIntCSSPixels(margin.top);
+
+ SetPopupPosition(nullptr, true, false, true);
+
+ nsCOMPtr<nsIContent> popup = mContent;
+ if (aUpdateAttrs && (popup->HasAttr(kNameSpaceID_None, nsGkAtoms::left) ||
+ popup->HasAttr(kNameSpaceID_None, nsGkAtoms::top)))
+ {
+ nsAutoString left, top;
+ left.AppendInt(aPos.x);
+ top.AppendInt(aPos.y);
+ popup->SetAttr(kNameSpaceID_None, nsGkAtoms::left, left, false);
+ popup->SetAttr(kNameSpaceID_None, nsGkAtoms::top, top, false);
+ }
+}
+
+void
+nsMenuPopupFrame::MoveToAnchor(nsIContent* aAnchorContent,
+ const nsAString& aPosition,
+ int32_t aXPos, int32_t aYPos,
+ bool aAttributesOverride)
+{
+ NS_ASSERTION(IsVisible(), "popup must be visible to move it");
+
+ nsPopupState oldstate = mPopupState;
+ InitializePopup(aAnchorContent, mTriggerContent, aPosition,
+ aXPos, aYPos, MenuPopupAnchorType_Node, aAttributesOverride);
+ // InitializePopup changed the state so reset it.
+ mPopupState = oldstate;
+
+ // Pass false here so that flipping and adjusting to fit on the screen happen.
+ SetPopupPosition(nullptr, false, false, true);
+}
+
+bool
+nsMenuPopupFrame::GetAutoPosition()
+{
+ return mShouldAutoPosition;
+}
+
+void
+nsMenuPopupFrame::SetAutoPosition(bool aShouldAutoPosition)
+{
+ mShouldAutoPosition = aShouldAutoPosition;
+}
+
+void
+nsMenuPopupFrame::SetConsumeRollupEvent(uint32_t aConsumeMode)
+{
+ mConsumeRollupEvent = aConsumeMode;
+}
+
+int8_t
+nsMenuPopupFrame::GetAlignmentPosition() const
+{
+ // The code below handles most cases of alignment, anchor and position values. Those that are
+ // not handled just return POPUPPOSITION_UNKNOWN.
+
+ if (mPosition == POPUPPOSITION_OVERLAP || mPosition == POPUPPOSITION_AFTERPOINTER ||
+ mPosition == POPUPPOSITION_SELECTION)
+ return mPosition;
+
+ int8_t position = mPosition;
+
+ if (position == POPUPPOSITION_UNKNOWN) {
+ switch (mPopupAnchor) {
+ case POPUPALIGNMENT_BOTTOMCENTER:
+ position = mPopupAlignment == POPUPALIGNMENT_TOPRIGHT ?
+ POPUPPOSITION_AFTEREND : POPUPPOSITION_AFTERSTART;
+ break;
+ case POPUPALIGNMENT_TOPCENTER:
+ position = mPopupAlignment == POPUPALIGNMENT_BOTTOMRIGHT ?
+ POPUPPOSITION_BEFOREEND : POPUPPOSITION_BEFORESTART;
+ break;
+ case POPUPALIGNMENT_LEFTCENTER:
+ position = mPopupAlignment == POPUPALIGNMENT_BOTTOMRIGHT ?
+ POPUPPOSITION_STARTAFTER : POPUPPOSITION_STARTBEFORE;
+ break;
+ case POPUPALIGNMENT_RIGHTCENTER:
+ position = mPopupAlignment == POPUPALIGNMENT_BOTTOMLEFT ?
+ POPUPPOSITION_ENDAFTER : POPUPPOSITION_ENDBEFORE;
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (mHFlip) {
+ position = POPUPPOSITION_HFLIP(position);
+ }
+
+ if (mVFlip) {
+ position = POPUPPOSITION_VFLIP(position);
+ }
+
+ return position;
+}
+
+/**
+ * KEEP THIS IN SYNC WITH nsContainerFrame::CreateViewForFrame
+ * as much as possible. Until we get rid of views finally...
+ */
+void
+nsMenuPopupFrame::CreatePopupView()
+{
+ if (HasView()) {
+ return;
+ }
+
+ nsViewManager* viewManager = PresContext()->GetPresShell()->GetViewManager();
+ NS_ASSERTION(nullptr != viewManager, "null view manager");
+
+ // Create a view
+ nsView* parentView = viewManager->GetRootView();
+ nsViewVisibility visibility = nsViewVisibility_kHide;
+ int32_t zIndex = INT32_MAX;
+ bool autoZIndex = false;
+
+ NS_ASSERTION(parentView, "no parent view");
+
+ // Create a view
+ nsView *view = viewManager->CreateView(GetRect(), parentView, visibility);
+ viewManager->SetViewZIndex(view, autoZIndex, zIndex);
+ // XXX put view last in document order until we can do better
+ viewManager->InsertChild(parentView, view, nullptr, true);
+
+ // Remember our view
+ SetView(view);
+
+ NS_FRAME_LOG(NS_FRAME_TRACE_CALLS,
+ ("nsMenuPopupFrame::CreatePopupView: frame=%p view=%p", this, view));
+}