layout/xul/nsXULPopupManager.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /**
   8  * The XUL Popup Manager keeps track of all open popups.
   9  */
  10
  11 #ifndef nsXULPopupManager_h__
  12 #define nsXULPopupManager_h__
  13
  14 #include "mozilla/Logging.h"
  15 #include "nsHashtablesFwd.h"
  16 #include "nsIContent.h"
  17 #include "nsIRollupListener.h"
  18 #include "nsIDOMEventListener.h"
  19 #include "Units.h"
  20 #include "nsPoint.h"
  21 #include "nsCOMPtr.h"
  22 #include "nsTArray.h"
  23 #include "nsIObserver.h"
  24 #include "nsThreadUtils.h"
  25 #include "mozilla/Attributes.h"
  26 #include "mozilla/widget/InitData.h"
  27 #include "mozilla/widget/NativeMenu.h"
  28
  29 // XXX Avoid including this here by moving function bodies to the cpp file.
  30 #include "mozilla/dom/Element.h"
  31
  32 // X.h defines KeyPress
  33 #ifdef KeyPress
  34 #  undef KeyPress
  35 #endif
  36
  37 /**
  38  * There are two types that are used:
  39  *   - dismissable popups such as menus, which should close up when there is a
  40  *     click outside the popup. In this situation, the entire chain of menus
  41  *     above should also be closed.
  42  *   - panels, which stay open until a request is made to close them. This
  43  *     type is used by tooltips.
  44  *
  45  * When a new popup is opened, it is appended to the popup chain, stored in a
  46  * linked list in mPopups.
  47  * Popups are stored in this list linked from newest to oldest. When a click
  48  * occurs outside one of the open dismissable popups, the chain is closed by
  49  * calling Rollup.
  50  */
  51
  52 class nsContainerFrame;
  53 class nsITimer;
  54 class nsIDocShellTreeItem;
  55 class nsMenuPopupFrame;
  56 class nsPIDOMWindowOuter;
  57 class nsRefreshDriver;
  58
  59 namespace mozilla {
  60 class PresShell;
  61 namespace dom {
  62 class Event;
  63 class KeyboardEvent;
  64 class UIEvent;
  65 class XULButtonElement;
  66 class XULMenuBarElement;
  67 class XULPopupElement;
  68 }  // namespace dom
  69 }  // namespace mozilla
  70
  71 // XUL popups can be in several different states. When opening a popup, the
  72 // state changes as follows:
  73 //   ePopupClosed - initial state
  74 //   ePopupShowing - during the period when the popupshowing event fires
  75 //   ePopupOpening - between the popupshowing event and being visible. Creation
  76 //                   of the child frames, layout and reflow occurs in this
  77 //                   state. The popup is stored in the popup manager's list of
  78 //                   open popups during this state.
  79 //   ePopupVisible - layout is done and the popup's view and widget are made
  80 //                   visible. The popup is visible on screen but may be
  81 //                   transitioning. The popupshown event has not yet fired.
  82 //   ePopupShown - the popup has been shown and is fully ready. This state is
  83 //                 assigned just before the popupshown event fires.
  84 // When closing a popup:
  85 //   ePopupHidden - during the period when the popuphiding event fires and
  86 //                  the popup is removed.
  87 //   ePopupClosed - the popup's widget is made invisible.
  88 enum nsPopupState {
  89   // state when a popup is not open
  90   ePopupClosed,
  91   // state from when a popup is requested to be shown to after the
  92   // popupshowing event has been fired.
  93   ePopupShowing,
  94   // state while a popup is waiting to be laid out and positioned
  95   ePopupPositioning,
  96   // state while a popup is open but the widget is not yet visible
  97   ePopupOpening,
  98   // state while a popup is visible and waiting for the popupshown event
  99   ePopupVisible,
 100   // state while a popup is open and visible on screen
 101   ePopupShown,
 102   // state from when a popup is requested to be hidden to when it is closed.
 103   ePopupHiding,
 104   // state which indicates that the popup was hidden without firing the
 105   // popuphiding or popuphidden events. It is used when executing a menu
 106   // command because the menu needs to be hidden before the command event
 107   // fires, yet the popuphiding and popuphidden events are fired after. This
 108   // state can also occur when the popup is removed because the document is
 109   // unloaded.
 110   ePopupInvisible
 111 };
 112
 113 // when a menu command is executed, the closemenu attribute may be used
 114 // to define how the menu should be closed up
 115 enum CloseMenuMode {
 116   CloseMenuMode_Auto,   // close up the chain of menus, default value
 117   CloseMenuMode_None,   // don't close up any menus
 118   CloseMenuMode_Single  // close up only the menu the command is inside
 119 };
 120
 121 /**
 122  * nsNavigationDirection: an enum expressing navigation through the menus in
 123  * terms which are independent of the directionality of the chrome. The
 124  * terminology, derived from XSL-FO and CSS3 (e.g.
 125  * http://www.w3.org/TR/css3-text/#TextLayout), is BASE (Before, After, Start,
 126  * End), with the addition of First and Last (mapped to Home and End
 127  * respectively).
 128  *
 129  * In languages such as English where the inline progression is left-to-right
 130  * and the block progression is top-to-bottom (lr-tb), these terms will map out
 131  * as in the following diagram
 132  *
 133  *  --- inline progression --->
 134  *
 135  *           First              |
 136  *           ...                |
 137  *           Before             |
 138  *         +--------+         block
 139  *   Start |        | End  progression
 140  *         +--------+           |
 141  *           After              |
 142  *           ...                |
 143  *           Last               V
 144  *
 145  */
 146
 147 enum nsNavigationDirection {
 148   eNavigationDirection_Last,
 149   eNavigationDirection_First,
 150   eNavigationDirection_Start,
 151   eNavigationDirection_Before,
 152   eNavigationDirection_End,
 153   eNavigationDirection_After
 154 };
 155
 156 enum nsIgnoreKeys {
 157   eIgnoreKeys_False,
 158   eIgnoreKeys_True,
 159   eIgnoreKeys_Shortcuts,
 160 };
 161
 162 enum class HidePopupOption : uint8_t {
 163   // If the entire chain of menus should be closed.
 164   HideChain,
 165   // If the parent <menu> of the popup should not be deselected. This will not
 166   // be set when the menu is closed by pressing the Escape key.
 167   DeselectMenu,
 168   // If the first popuphiding event should be sent asynchrously. This should
 169   // be set if HidePopup is called from a frame.
 170   Async,
 171   // If this popup is hiding due to being cancelled.
 172   IsRollup,
 173   // Whether animations should be disabled for rolled-up popups.
 174   DisableAnimations,
 175 };
 176
 177 using HidePopupOptions = mozilla::EnumSet<HidePopupOption>;
 178
 179 /**
 180  * DirectionFromKeyCodeTable: two arrays, the first for left-to-right and the
 181  * other for right-to-left, that map keycodes to values of
 182  * nsNavigationDirection.
 183  */
 184 extern const nsNavigationDirection DirectionFromKeyCodeTable[2][6];
 185
 186 #define NS_DIRECTION_FROM_KEY_CODE(frame, keycode) \
 187   (DirectionFromKeyCodeTable[static_cast<uint8_t>( \
 188       (frame)->StyleVisibility()->mDirection)][(   \
 189       keycode)-mozilla::dom::KeyboardEvent_Binding::DOM_VK_END])
 190
 191 // Used to hold information about a popup that is about to be opened.
 192 struct PendingPopup {
 193   using Element = mozilla::dom::Element;
 194   using Event = mozilla::dom::Event;
 195
 196   PendingPopup(Element* aPopup, Event* aEvent);
 197
 198   const RefPtr<Element> mPopup;
 199   const RefPtr<Event> mEvent;
 200
 201   // Device pixels relative to the showing popup's presshell's
 202   // root prescontext's root frame.
 203   mozilla::LayoutDeviceIntPoint mMousePoint;
 204
 205   // Cached modifiers used to trigger the popup.
 206   mozilla::Modifiers mModifiers;
 207
 208   already_AddRefed<nsIContent> GetTriggerContent() const;
 209
 210   void InitMousePoint();
 211
 212   void SetMousePoint(mozilla::LayoutDeviceIntPoint aMousePoint) {
 213     mMousePoint = aMousePoint;
 214   }
 215
 216   uint16_t MouseInputSource() const;
 217 };
 218
 219 // nsMenuChainItem holds info about an open popup. Items are stored in a
 220 // doubly linked list. Note that the linked list is stored beginning from
 221 // the lowest child in a chain of menus, as this is the active submenu.
 222 class nsMenuChainItem {
 223   using PopupType = mozilla::widget::PopupType;
 224
 225   nsMenuPopupFrame* mFrame;  // the popup frame
 226   PopupType mPopupType;      // the popup type of the frame
 227   bool mNoAutoHide;          // true for noautohide panels
 228   bool mIsContext;           // true for context menus
 229   bool mOnMenuBar;           // true if the menu is on a menu bar
 230   nsIgnoreKeys mIgnoreKeys;  // indicates how keyboard listeners should be used
 231
 232   // True if the popup should maintain its position relative to the anchor when
 233   // the anchor moves.
 234   bool mFollowAnchor;
 235
 236   // The last seen position of the anchor, relative to the screen.
 237   nsRect mCurrentRect;
 238
 239   mozilla::UniquePtr<nsMenuChainItem> mParent;
 240   // Back pointer, safe because mChild keeps us alive.
 241   nsMenuChainItem* mChild = nullptr;
 242
 243  public:
 244   nsMenuChainItem(nsMenuPopupFrame* aFrame, bool aNoAutoHide, bool aIsContext,
 245                   PopupType aPopupType)
 246       : mFrame(aFrame),
 247         mPopupType(aPopupType),
 248         mNoAutoHide(aNoAutoHide),
 249         mIsContext(aIsContext),
 250         mOnMenuBar(false),
 251         mIgnoreKeys(eIgnoreKeys_False),
 252         mFollowAnchor(false) {
 253     NS_ASSERTION(aFrame, "null frame passed to nsMenuChainItem constructor");
 254     MOZ_COUNT_CTOR(nsMenuChainItem);
 255   }
 256
 257   MOZ_COUNTED_DTOR(nsMenuChainItem)
 258
 259   mozilla::dom::XULPopupElement* Element();
 260   nsMenuPopupFrame* Frame() { return mFrame; }
 261   PopupType GetPopupType() { return mPopupType; }
 262   bool IsNoAutoHide() { return mNoAutoHide; }
 263   void SetNoAutoHide(bool aNoAutoHide) { mNoAutoHide = aNoAutoHide; }
 264   bool IsMenu() { return mPopupType == PopupType::Menu; }
 265   bool IsContextMenu() { return mIsContext; }
 266   nsIgnoreKeys IgnoreKeys() { return mIgnoreKeys; }
 267   void SetIgnoreKeys(nsIgnoreKeys aIgnoreKeys) { mIgnoreKeys = aIgnoreKeys; }
 268   bool IsOnMenuBar() { return mOnMenuBar; }
 269   void SetOnMenuBar(bool aOnMenuBar) { mOnMenuBar = aOnMenuBar; }
 270   nsMenuChainItem* GetParent() { return mParent.get(); }
 271   nsMenuChainItem* GetChild() { return mChild; }
 272   bool FollowsAnchor() { return mFollowAnchor; }
 273   void UpdateFollowAnchor();
 274   void CheckForAnchorChange();
 275
 276   // set the parent of this item to aParent, also changing the parent
 277   // to have this as a child.
 278   void SetParent(mozilla::UniquePtr<nsMenuChainItem> aParent);
 279   // Removes the parent pointer and returns it.
 280   mozilla::UniquePtr<nsMenuChainItem> Detach();
 281 };
 282
 283 // this class is used for dispatching popuphiding events asynchronously.
 284 class nsXULPopupHidingEvent : public mozilla::Runnable {
 285   using PopupType = mozilla::widget::PopupType;
 286   using Element = mozilla::dom::Element;
 287
 288  public:
 289   nsXULPopupHidingEvent(Element* aPopup, Element* aNextPopup,
 290                         Element* aLastPopup, PopupType aPopupType,
 291                         HidePopupOptions aOptions)
 292       : mozilla::Runnable("nsXULPopupHidingEvent"),
 293         mPopup(aPopup),
 294         mNextPopup(aNextPopup),
 295         mLastPopup(aLastPopup),
 296         mPopupType(aPopupType),
 297         mOptions(aOptions) {
 298     NS_ASSERTION(aPopup,
 299                  "null popup supplied to nsXULPopupHidingEvent constructor");
 300     // aNextPopup and aLastPopup may be null
 301   }
 302
 303   NS_IMETHOD Run() override;
 304
 305  private:
 306   nsCOMPtr<Element> mPopup;
 307   nsCOMPtr<Element> mNextPopup;
 308   nsCOMPtr<Element> mLastPopup;
 309   PopupType mPopupType;
 310   HidePopupOptions mOptions;
 311 };
 312
 313 // this class is used for dispatching popuppositioned events asynchronously.
 314 class nsXULPopupPositionedEvent : public mozilla::Runnable {
 315   using Element = mozilla::dom::Element;
 316
 317  public:
 318   explicit nsXULPopupPositionedEvent(Element* aPopup)
 319       : mozilla::Runnable("nsXULPopupPositionedEvent"), mPopup(aPopup) {
 320     MOZ_ASSERT(aPopup);
 321   }
 322
 323   NS_IMETHOD Run() override;
 324
 325   // Asynchronously dispatch a popuppositioned event at aPopup if this is a
 326   // panel that should receieve such events. Return true if the event was sent.
 327   static bool DispatchIfNeeded(Element* aPopup);
 328
 329  private:
 330   const nsCOMPtr<Element> mPopup;
 331 };
 332
 333 // this class is used for dispatching menu command events asynchronously.
 334 class nsXULMenuCommandEvent : public mozilla::Runnable {
 335   using Element = mozilla::dom::Element;
 336
 337  public:
 338   nsXULMenuCommandEvent(Element* aMenu, bool aIsTrusted,
 339                         mozilla::Modifiers aModifiers, bool aUserInput,
 340                         bool aFlipChecked, int16_t aButton)
 341       : mozilla::Runnable("nsXULMenuCommandEvent"),
 342         mMenu(aMenu),
 343         mModifiers(aModifiers),
 344         mButton(aButton),
 345         mIsTrusted(aIsTrusted),
 346         mUserInput(aUserInput),
 347         mFlipChecked(aFlipChecked),
 348         mCloseMenuMode(CloseMenuMode_Auto) {
 349     NS_ASSERTION(aMenu,
 350                  "null menu supplied to nsXULMenuCommandEvent constructor");
 351   }
 352
 353   MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override;
 354
 355   void SetCloseMenuMode(CloseMenuMode aCloseMenuMode) {
 356     mCloseMenuMode = aCloseMenuMode;
 357   }
 358
 359  private:
 360   RefPtr<Element> mMenu;
 361
 362   mozilla::Modifiers mModifiers;
 363   int16_t mButton;
 364   bool mIsTrusted;
 365   bool mUserInput;
 366   bool mFlipChecked;
 367   CloseMenuMode mCloseMenuMode;
 368 };
 369
 370 class nsXULPopupManager final : public nsIDOMEventListener,
 371                                 public nsIRollupListener,
 372                                 public nsIObserver,
 373                                 public mozilla::widget::NativeMenu::Observer {
 374  public:
 375   friend class nsXULPopupHidingEvent;
 376   friend class nsXULPopupPositionedEvent;
 377   friend class nsXULMenuCommandEvent;
 378   friend class TransitionEnder;
 379
 380   using PopupType = mozilla::widget::PopupType;
 381   using Element = mozilla::dom::Element;
 382
 383   NS_DECL_ISUPPORTS
 384   NS_DECL_NSIOBSERVER
 385   NS_DECL_NSIDOMEVENTLISTENER
 386
 387   // nsIRollupListener
 388   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 389   bool Rollup(const RollupOptions&,
 390               nsIContent** aLastRolledUp = nullptr) override;
 391   bool ShouldRollupOnMouseWheelEvent() override;
 392   bool ShouldConsumeOnMouseWheelEvent() override;
 393   bool ShouldRollupOnMouseActivate() override;
 394   uint32_t GetSubmenuWidgetChain(nsTArray<nsIWidget*>* aWidgetChain) override;
 395   nsIWidget* GetRollupWidget() override;
 396   bool RollupNativeMenu() override;
 397
 398   MOZ_CAN_RUN_SCRIPT_BOUNDARY bool RollupTooltips();
 399
 400   enum class RollupKind { Tooltip, Menu };
 401   MOZ_CAN_RUN_SCRIPT
 402   bool RollupInternal(RollupKind, const RollupOptions&,
 403                       nsIContent** aLastRolledUp);
 404
 405   // NativeMenu::Observer
 406   void OnNativeMenuOpened() override;
 407   void OnNativeMenuClosed() override;
 408   void OnNativeSubMenuWillOpen(mozilla::dom::Element* aPopupElement) override;
 409   void OnNativeSubMenuDidOpen(mozilla::dom::Element* aPopupElement) override;
 410   void OnNativeSubMenuClosed(mozilla::dom::Element* aPopupElement) override;
 411   MOZ_CAN_RUN_SCRIPT_BOUNDARY void OnNativeMenuWillActivateItem(
 412       mozilla::dom::Element* aMenuItemElement) override;
 413
 414   static nsXULPopupManager* sInstance;
 415
 416   // initialize and shutdown methods called by nsLayoutStatics
 417   static nsresult Init();
 418   static void Shutdown();
 419
 420   // returns a weak reference to the popup manager instance, could return null
 421   // if a popup manager could not be allocated
 422   static nsXULPopupManager* GetInstance();
 423
 424   // This should be called when a window is moved or resized to adjust the
 425   // popups accordingly.
 426   void AdjustPopupsOnWindowChange(nsPIDOMWindowOuter* aWindow);
 427   void AdjustPopupsOnWindowChange(mozilla::PresShell* aPresShell);
 428
 429   // inform the popup manager that a menu bar has been activated or deactivated,
 430   // either because one of its menus has opened or closed, or that the menubar
 431   // has been focused such that its menus may be navigated with the keyboard.
 432   // aActivate should be true when the menubar should be focused, and false
 433   // when the active menu bar should be defocused. In the latter case, if
 434   // aMenuBar isn't currently active, yet another menu bar is, that menu bar
 435   // will remain active.
 436   void SetActiveMenuBar(mozilla::dom::XULMenuBarElement* aMenuBar,
 437                         bool aActivate);
 438
 439   struct MayShowMenuResult {
 440     const bool mIsNative = false;
 441     mozilla::dom::XULButtonElement* const mMenuButton = nullptr;
 442     nsMenuPopupFrame* const mMenuPopupFrame = nullptr;
 443
 444     explicit operator bool() const {
 445       MOZ_ASSERT(!!mMenuButton == !!mMenuPopupFrame);
 446       return mIsNative || mMenuButton;
 447     }
 448   };
 449
 450   MayShowMenuResult MayShowMenu(nsIContent* aMenu);
 451
 452   /**
 453    * Open a <menu> given its content node. If aSelectFirstItem is
 454    * set to true, the first item on the menu will automatically be
 455    * selected.
 456    */
 457   void ShowMenu(nsIContent* aMenu, bool aSelectFirstItem);
 458
 459   /**
 460    * Open a popup, either anchored or unanchored. If aSelectFirstItem is
 461    * true, then the first item in the menu is selected. The arguments are
 462    * similar to those for XULPopupElement::OpenPopup.
 463    *
 464    * aTriggerEvent should be the event that triggered the event. This is used
 465    * to determine the coordinates and trigger node for the popup. This may be
 466    * null if the popup was not triggered by an event.
 467    *
 468    * This fires the popupshowing event synchronously.
 469    */
 470   void ShowPopup(Element* aPopup, nsIContent* aAnchorContent,
 471                  const nsAString& aPosition, int32_t aXPos, int32_t aYPos,
 472                  bool aIsContextMenu, bool aAttributesOverride,
 473                  bool aSelectFirstItem, mozilla::dom::Event* aTriggerEvent);
 474
 475   /**
 476    * Open a popup at a specific screen position specified by aXPos and aYPos,
 477    * measured in CSS pixels.
 478    *
 479    * This fires the popupshowing event synchronously.
 480    *
 481    * If aIsContextMenu is true, the popup is positioned at a slight
 482    * offset from aXPos/aYPos to ensure that it is not under the mouse
 483    * cursor.
 484    */
 485   void ShowPopupAtScreen(Element* aPopup, int32_t aXPos, int32_t aYPos,
 486                          bool aIsContextMenu,
 487                          mozilla::dom::Event* aTriggerEvent);
 488
 489   /* Open a popup anchored at a screen rectangle specified by aRect.
 490    * The remaining arguments are similar to ShowPopup.
 491    */
 492   void ShowPopupAtScreenRect(Element* aPopup, const nsAString& aPosition,
 493                              const nsIntRect& aRect, bool aIsContextMenu,
 494                              bool aAttributesOverride,
 495                              mozilla::dom::Event* aTriggerEvent);
 496
 497   /**
 498    * Open a popup as a native menu, at a specific screen position specified by
 499    * aXPos and aYPos, measured in CSS pixels.
 500    *
 501    * This fires the popupshowing event synchronously.
 502    *
 503    * Returns whether native menus are supported for aPopup on this platform.
 504    * TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230)
 505    */
 506   MOZ_CAN_RUN_SCRIPT_BOUNDARY bool ShowPopupAsNativeMenu(
 507       Element* aPopup, int32_t aXPos, int32_t aYPos, bool aIsContextMenu,
 508       mozilla::dom::Event* aTriggerEvent);
 509
 510   /**
 511    * Open a tooltip at a specific screen position specified by aXPos and aYPos,
 512    * measured in device pixels. This fires the popupshowing event synchronously.
 513    */
 514   void ShowTooltipAtScreen(Element* aPopup, nsIContent* aTriggerContent,
 515                            const mozilla::LayoutDeviceIntPoint&);
 516
 517   /*
 518    * Hide a popup aPopup. If the popup is in a <menu>, then also inform the
 519    * menu that the popup is being hidden.
 520    * aLastPopup - optional popup to close last when hiding a chain of menus.
 521    *              If null, then all popups will be closed.
 522    */
 523   void HidePopup(Element* aPopup, HidePopupOptions,
 524                  Element* aLastPopup = nullptr);
 525
 526   /*
 527    * Hide the popup of a <menu>.
 528    */
 529   void HideMenu(nsIContent* aMenu);
 530
 531   /**
 532    * Hide a popup after a short delay. This is used when rolling over menu
 533    * items. This timer is stored in mCloseTimer. The timer may be cancelled and
 534    * the popup closed by calling KillMenuTimer.
 535    */
 536   void HidePopupAfterDelay(nsMenuPopupFrame* aPopup, int32_t aDelay);
 537
 538   /**
 539    * Hide all of the popups from a given docshell. This should be called when
 540    * the document is hidden.
 541    */
 542   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 543   void HidePopupsInDocShell(nsIDocShellTreeItem* aDocShellToHide);
 544
 545   /**
 546    * Check if any popups need to be repositioned or hidden after a style or
 547    * layout change. This will update, for example, any arrow type panels when
 548    * the anchor that is is pointing to has moved, resized or gone away.
 549    * Only those popups that pertain to the supplied aRefreshDriver are updated.
 550    */
 551   void UpdatePopupPositions(nsRefreshDriver* aRefreshDriver);
 552
 553   /**
 554    * Enable or disable anchor following on the popup if needed.
 555    */
 556   void UpdateFollowAnchor(nsMenuPopupFrame* aPopup);
 557
 558   /**
 559    * Execute a menu command from the triggering event aEvent.
 560    *
 561    * aMenu - a menuitem to execute
 562    * aEvent - an nsXULMenuCommandEvent that contains all the info from the mouse
 563    *          event which triggered the menu to be executed, may not be null
 564    */
 565   MOZ_CAN_RUN_SCRIPT void ExecuteMenu(nsIContent* aMenu,
 566                                       nsXULMenuCommandEvent* aEvent);
 567
 568   /**
 569    * If a native menu is open, and aItem is an item in the menu's subtree,
 570    * execute the item with the help of the native menu and close the menu.
 571    * Returns true if a native menu was open.
 572    */
 573   bool ActivateNativeMenuItem(nsIContent* aItem, mozilla::Modifiers aModifiers,
 574                               int16_t aButton, mozilla::ErrorResult& aRv);
 575
 576   /**
 577    * Return true if the popup for the supplied content node is open.
 578    */
 579   bool IsPopupOpen(Element* aPopup);
 580
 581   /**
 582    * Return the frame for the topmost open popup of a given type, or null if
 583    * no popup of that type is open. If aType is PopupType::Any, a menu of any
 584    * type is returned.
 585    */
 586   nsIFrame* GetTopPopup(PopupType aType);
 587
 588   /**
 589    * Returns the topmost active menuitem that's currently visible, if any.
 590    */
 591   nsIContent* GetTopActiveMenuItemContent();
 592
 593   /**
 594    * Return an array of all the open and visible popup frames for
 595    * menus, in order from top to bottom.
 596    */
 597   void GetVisiblePopups(nsTArray<nsIFrame*>& aPopups);
 598
 599   /**
 600    * Get the node that last triggered a popup or tooltip in the document
 601    * aDocument. aDocument must be non-null and be a document contained within
 602    * the same window hierarchy as the popup to retrieve.
 603    */
 604   already_AddRefed<nsINode> GetLastTriggerPopupNode(
 605       mozilla::dom::Document* aDocument) {
 606     return GetLastTriggerNode(aDocument, false);
 607   }
 608
 609   already_AddRefed<nsINode> GetLastTriggerTooltipNode(
 610       mozilla::dom::Document* aDocument) {
 611     return GetLastTriggerNode(aDocument, true);
 612   }
 613
 614   /**
 615    * Return false if a popup may not be opened. This will return false if the
 616    * popup is already open, if the popup is in a content shell that is not
 617    * focused, or if it is a submenu of another menu that isn't open.
 618    */
 619   bool MayShowPopup(nsMenuPopupFrame* aFrame);
 620
 621   /**
 622    * Indicate that the popup associated with aView has been moved to the
 623    * specified device pixel coordinates.
 624    */
 625   void PopupMoved(nsIFrame* aFrame, const mozilla::LayoutDeviceIntPoint& aPoint,
 626                   bool aByMoveToRect);
 627
 628   /**
 629    * Indicate that the popup associated with aView has been resized to the
 630    * given device pixel size aSize.
 631    */
 632   void PopupResized(nsIFrame* aFrame,
 633                     const mozilla::LayoutDeviceIntSize& aSize);
 634
 635   /**
 636    * Called when a popup frame is destroyed. In this case, just remove the
 637    * item and later popups from the list. No point going through HidePopup as
 638    * the frames have gone away.
 639    */
 640   MOZ_CAN_RUN_SCRIPT void PopupDestroyed(nsMenuPopupFrame* aFrame);
 641
 642   /**
 643    * Returns true if there is a context menu open. If aPopup is specified,
 644    * then the context menu must be later in the chain than aPopup. If aPopup
 645    * is null, returns true if any context menu at all is open.
 646    */
 647   bool HasContextMenu(nsMenuPopupFrame* aPopup);
 648
 649   /**
 650    * Update the commands for the menus within the menu popup for a given
 651    * content node. aPopup should be a XUL menupopup element. This method
 652    * changes attributes on the children of aPopup, and deals only with the
 653    * content of the popup, not the frames.
 654    */
 655   void UpdateMenuItems(Element* aPopup);
 656
 657   /**
 658    * Stop the timer which hides a popup after a delay, started by a previous
 659    * call to HidePopupAfterDelay. In addition, the popup awaiting to be hidden
 660    * is closed asynchronously.
 661    */
 662   void KillMenuTimer();
 663
 664   /**
 665    * Cancel the timer which closes menus after delay, but only if the menu to
 666    * close is aMenuParent. When a submenu is opened, the user might move the
 667    * mouse over a sibling menuitem which would normally close the menu. This
 668    * menu is closed via a timer. However, if the user moves the mouse over the
 669    * submenu before the timer fires, we should instead cancel the timer. This
 670    * ensures that the user can move the mouse diagonally over a menu.
 671    */
 672   void CancelMenuTimer(nsMenuPopupFrame*);
 673
 674   /**
 675    * Handles navigation for menu accelkeys. If aFrame is specified, then the
 676    * key is handled by that popup, otherwise if aFrame is null, the key is
 677    * handled by the active popup or menubar.
 678    */
 679   MOZ_CAN_RUN_SCRIPT bool HandleShortcutNavigation(
 680       mozilla::dom::KeyboardEvent& aKeyEvent, nsMenuPopupFrame* aFrame);
 681
 682   /**
 683    * Handles cursor navigation within a menu. Returns true if the key has
 684    * been handled.
 685    */
 686   MOZ_CAN_RUN_SCRIPT bool HandleKeyboardNavigation(uint32_t aKeyCode);
 687
 688   /**
 689    * Handle keyboard navigation within a menu popup specified by aFrame.
 690    * Returns true if the key was handled and other default handling
 691    * should not occur.
 692    */
 693   MOZ_CAN_RUN_SCRIPT bool HandleKeyboardNavigationInPopup(
 694       nsMenuPopupFrame* aFrame, nsNavigationDirection aDir) {
 695     return HandleKeyboardNavigationInPopup(nullptr, aFrame, aDir);
 696   }
 697
 698   /**
 699    * Handles the keyboard event with keyCode value. Returns true if the event
 700    * has been handled.
 701    */
 702   MOZ_CAN_RUN_SCRIPT bool HandleKeyboardEventWithKeyCode(
 703       mozilla::dom::KeyboardEvent* aKeyEvent,
 704       nsMenuChainItem* aTopVisibleMenuItem);
 705
 706   // Sets mIgnoreKeys of the Top Visible Menu Item
 707   nsresult UpdateIgnoreKeys(bool aIgnoreKeys);
 708
 709   nsPopupState GetPopupState(mozilla::dom::Element* aPopupElement);
 710
 711   mozilla::dom::Event* GetOpeningPopupEvent() const {
 712     return mPendingPopup->mEvent.get();
 713   }
 714
 715   MOZ_CAN_RUN_SCRIPT nsresult KeyUp(mozilla::dom::KeyboardEvent* aKeyEvent);
 716   MOZ_CAN_RUN_SCRIPT nsresult KeyDown(mozilla::dom::KeyboardEvent* aKeyEvent);
 717   MOZ_CAN_RUN_SCRIPT nsresult KeyPress(mozilla::dom::KeyboardEvent* aKeyEvent);
 718
 719  protected:
 720   nsXULPopupManager();
 721   ~nsXULPopupManager();
 722
 723   // get the nsMenuPopupFrame, if any, for the given content node
 724   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 725   nsMenuPopupFrame* GetPopupFrameForContent(nsIContent* aContent,
 726                                             bool aShouldFlush);
 727
 728   // Get the menu to start rolling up.
 729   nsMenuChainItem* GetRollupItem(RollupKind);
 730
 731   // Return the topmost menu, skipping over invisible popups
 732   nsMenuChainItem* GetTopVisibleMenu() {
 733     return GetRollupItem(RollupKind::Menu);
 734   }
 735
 736   // Removes the chain item from the chain and deletes it.
 737   void RemoveMenuChainItem(nsMenuChainItem*);
 738
 739   // Hide all of the visible popups from the given list. This function can
 740   // cause style changes and frame destruction.
 741   MOZ_CAN_RUN_SCRIPT void HidePopupsInList(
 742       const nsTArray<nsMenuPopupFrame*>& aFrames);
 743
 744   // Hide, but don't close, visible menus. Called before executing a menu item.
 745   // The caller promises to close the menus properly (with a call to HidePopup)
 746   // once the item has been executed.
 747   MOZ_CAN_RUN_SCRIPT void HideOpenMenusBeforeExecutingMenu(CloseMenuMode aMode);
 748
 749   // callbacks for ShowPopup and HidePopup as events may be done asynchronously
 750   MOZ_CAN_RUN_SCRIPT void ShowPopupCallback(Element* aPopup,
 751                                             nsMenuPopupFrame* aPopupFrame,
 752                                             bool aIsContextMenu,
 753                                             bool aSelectFirstItem);
 754   MOZ_CAN_RUN_SCRIPT_BOUNDARY void HidePopupCallback(
 755       Element* aPopup, nsMenuPopupFrame* aPopupFrame, Element* aNextPopup,
 756       Element* aLastPopup, PopupType aPopupType, HidePopupOptions);
 757
 758   /**
 759    * Trigger frame construction and reflow in the popup, fire a popupshowing
 760    * event on the popup and then open the popup.
 761    *
 762    * aPendingPopup - information about the popup to open
 763    * aIsContextMenu - true for context menus
 764    * aSelectFirstItem - true to select the first item in the menu
 765    * TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230)
 766    */
 767   MOZ_CAN_RUN_SCRIPT_BOUNDARY void BeginShowingPopup(
 768       const PendingPopup& aPendingPopup, bool aIsContextMenu,
 769       bool aSelectFirstItem);
 770
 771   /**
 772    * Fire a popuphiding event and then hide the popup. This will be called
 773    * recursively if aNextPopup and aLastPopup are set in order to hide a chain
 774    * of open menus. If these are not set, only one popup is closed. However,
 775    * if the popup type indicates a menu, yet the next popup is not a menu,
 776    * then this ends the closing of popups. This allows a menulist inside a
 777    * non-menu to close up the menu but not close up the panel it is contained
 778    * within.
 779    *
 780    * The caller must keep a strong reference to aPopup, aNextPopup and
 781    * aLastPopup.
 782    *
 783    * aPopup - the popup to hide
 784    * aNextPopup - the next popup to hide
 785    * aLastPopup - the last popup in the chain to hide
 786    * aPresContext - nsPresContext for the popup's frame
 787    * aPopupType - the PopupType of the frame.
 788    * aOptions - the relevant options to hide the popup. Only a subset is looked
 789    * at.
 790    */
 791   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 792   void FirePopupHidingEvent(Element* aPopup, Element* aNextPopup,
 793                             Element* aLastPopup, nsPresContext* aPresContext,
 794                             PopupType aPopupType, HidePopupOptions aOptions);
 795
 796   /**
 797    * Handle keyboard navigation within a menu popup specified by aItem.
 798    */
 799   MOZ_CAN_RUN_SCRIPT
 800   bool HandleKeyboardNavigationInPopup(nsMenuChainItem* aItem,
 801                                        nsNavigationDirection aDir) {
 802     return HandleKeyboardNavigationInPopup(aItem, aItem->Frame(), aDir);
 803   }
 804
 805  private:
 806   /**
 807    * Handle keyboard navigation within a menu popup aFrame. If aItem is
 808    * supplied, then it is expected to have a frame equal to aFrame.
 809    * If aItem is non-null, then the navigation may be redirected to
 810    * an open submenu if one exists. Returns true if the key was
 811    * handled and other default handling should not occur.
 812    */
 813   MOZ_CAN_RUN_SCRIPT bool HandleKeyboardNavigationInPopup(
 814       nsMenuChainItem* aItem, nsMenuPopupFrame* aFrame,
 815       nsNavigationDirection aDir);
 816
 817  protected:
 818   already_AddRefed<nsINode> GetLastTriggerNode(
 819       mozilla::dom::Document* aDocument, bool aIsTooltip);
 820
 821   /**
 822    * Fire a popupshowing event for aPopup.
 823    */
 824   MOZ_CAN_RUN_SCRIPT nsEventStatus FirePopupShowingEvent(
 825       const PendingPopup& aPendingPopup, nsPresContext* aPresContext);
 826
 827   /**
 828    * Set mouse capturing for the current popup. This traps mouse clicks that
 829    * occur outside the popup so that it can be closed up. aOldPopup should be
 830    * set to the popup that was previously the current popup.
 831    */
 832   void SetCaptureState(nsIContent* aOldPopup);
 833
 834   /**
 835    * Key event listeners are attached to the document containing the current
 836    * menu for menu and shortcut navigation. Only one listener is needed at a
 837    * time, stored in mKeyListener, so switch it only if the document changes.
 838    * Having menus in different documents is very rare, so the listeners will
 839    * usually only be attached when the first menu opens and removed when all
 840    * menus have closed.
 841    *
 842    * This is also used when only a menubar is active without any open menus,
 843    * so that keyboard navigation between menus on the menubar may be done.
 844    */
 845   // TODO: Convert UpdateKeyboardListeners() to MOZ_CAN_RUN_SCRIPT and get rid
 846   //       of the kungFuDeathGrip in it.
 847   MOZ_CAN_RUN_SCRIPT_BOUNDARY void UpdateKeyboardListeners();
 848
 849   /*
 850    * Returns true if the docshell for aDoc is aExpected or a child of aExpected.
 851    */
 852   bool IsChildOfDocShell(mozilla::dom::Document* aDoc,
 853                          nsIDocShellTreeItem* aExpected);
 854
 855   // Finds a chain item in mPopups.
 856   nsMenuChainItem* FindPopup(Element* aPopup) const;
 857
 858   // the document the key event listener is attached to
 859   nsCOMPtr<mozilla::dom::EventTarget> mKeyListener;
 860
 861   // widget that is currently listening to rollup events
 862   nsCOMPtr<nsIWidget> mWidget;
 863
 864   // set to the currently active menu bar, if any
 865   mozilla::dom::XULMenuBarElement* mActiveMenuBar;
 866
 867   // linked list of normal menus and panels. mPopups points to the innermost
 868   // popup, which keeps alive all their parents.
 869   mozilla::UniquePtr<nsMenuChainItem> mPopups;
 870
 871   // timer used for HidePopupAfterDelay
 872   nsCOMPtr<nsITimer> mCloseTimer;
 873   nsMenuPopupFrame* mTimerMenu = nullptr;
 874
 875   // Information about the popup that is currently firing a popupshowing event.
 876   const PendingPopup* mPendingPopup;
 877
 878   // If a popup is displayed as a native menu, this is non-null while the
 879   // native menu is open.
 880   // mNativeMenu has a strong reference to the menupopup nsIContent.
 881   RefPtr<mozilla::widget::NativeMenu> mNativeMenu;
 882
 883   // If the currently open native menu activated an item, this is the item's
 884   // close menu mode. Nothing() if mNativeMenu is null or if no item was
 885   // activated.
 886   mozilla::Maybe<CloseMenuMode> mNativeMenuActivatedItemCloseMenuMode;
 887
 888   // If a popup is displayed as a native menu, this map contains the popup state
 889   // for any of its non-closed submenus. This state cannot be stored on the
 890   // submenus' nsMenuPopupFrames, because we usually don't generate frames for
 891   // the contents of native menus.
 892   // If a submenu is not present in this map, it means it's closed.
 893   // This map is empty if mNativeMenu is null.
 894   nsTHashMap<RefPtr<mozilla::dom::Element>, nsPopupState>
 895       mNativeMenuSubmenuStates;
 896 };
 897
 898 #endif