summaryrefslogtreecommitdiffstats
path: root/layout/xul/nsMenuPopupFrame.h
blob: e9f0b2a521764d0af695f0583648cab0d18db397 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

//
// nsMenuPopupFrame
//

#ifndef nsMenuPopupFrame_h__
#define nsMenuPopupFrame_h__

#include "mozilla/Attributes.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/StaticPrefs_ui.h"
#include "mozilla/TimeStamp.h"
#include "nsAtom.h"
#include "nsGkAtoms.h"
#include "nsCOMPtr.h"
#include "nsIDOMEventListener.h"
#include "nsXULPopupManager.h"

#include "nsBlockFrame.h"

#include "Units.h"

class nsIWidget;

namespace mozilla {
class PresShell;
namespace dom {
class KeyboardEvent;
class XULButtonElement;
class XULPopupElement;
}  // namespace dom
namespace widget {
enum class PopupLevel : uint8_t;
}
}  // namespace mozilla

enum ConsumeOutsideClicksResult {
  ConsumeOutsideClicks_ParentOnly =
      0,                          // Only consume clicks on the parent anchor
  ConsumeOutsideClicks_True = 1,  // Always consume clicks
  ConsumeOutsideClicks_Never = 2  // Never consume clicks
};

// How a popup may be flipped. Flipping to the outside edge is like how
// a submenu would work. The entire popup is flipped to the opposite side
// of the anchor.
enum FlipStyle {
  FlipStyle_None = 0,
  FlipStyle_Outside = 1,
  FlipStyle_Inside = 2
};

// Values for the flip attribute
enum FlipType {
  FlipType_Default = 0,
  FlipType_None = 1,  // don't try to flip or translate to stay onscreen
  FlipType_Both = 2,  // flip in both directions
  FlipType_Slide = 3  // allow the arrow to "slide" instead of resizing
};

enum MenuPopupAnchorType {
  MenuPopupAnchorType_Node = 0,   // anchored to a node
  MenuPopupAnchorType_Point = 1,  // unanchored and positioned at a screen point
  MenuPopupAnchorType_Rect = 2,   // anchored at a screen rectangle
};

// values are selected so that the direction can be flipped just by
// changing the sign
#define POPUPALIGNMENT_NONE 0
#define POPUPALIGNMENT_TOPLEFT 1
#define POPUPALIGNMENT_TOPRIGHT -1
#define POPUPALIGNMENT_BOTTOMLEFT 2
#define POPUPALIGNMENT_BOTTOMRIGHT -2

#define POPUPALIGNMENT_LEFTCENTER 16
#define POPUPALIGNMENT_RIGHTCENTER -16
#define POPUPALIGNMENT_TOPCENTER 17
#define POPUPALIGNMENT_BOTTOMCENTER 18

// The constants here are selected so that horizontally and vertically flipping
// can be easily handled using the two flip macros below.
#define POPUPPOSITION_UNKNOWN -1
#define POPUPPOSITION_BEFORESTART 0
#define POPUPPOSITION_BEFOREEND 1
#define POPUPPOSITION_AFTERSTART 2
#define POPUPPOSITION_AFTEREND 3
#define POPUPPOSITION_STARTBEFORE 4
#define POPUPPOSITION_ENDBEFORE 5
#define POPUPPOSITION_STARTAFTER 6
#define POPUPPOSITION_ENDAFTER 7
#define POPUPPOSITION_OVERLAP 8
#define POPUPPOSITION_AFTERPOINTER 9
#define POPUPPOSITION_SELECTION 10

#define POPUPPOSITION_HFLIP(v) (v ^ 1)
#define POPUPPOSITION_VFLIP(v) (v ^ 2)

nsIFrame* NS_NewMenuPopupFrame(mozilla::PresShell* aPresShell,
                               mozilla::ComputedStyle* aStyle);

class nsView;
class nsMenuPopupFrame;

// this class is used for dispatching popupshown events asynchronously.
class nsXULPopupShownEvent final : public mozilla::Runnable,
                                   public nsIDOMEventListener {
 public:
  nsXULPopupShownEvent(nsIContent* aPopup, nsPresContext* aPresContext)
      : mozilla::Runnable("nsXULPopupShownEvent"),
        mPopup(aPopup),
        mPresContext(aPresContext) {}

  NS_DECL_ISUPPORTS_INHERITED
  NS_DECL_NSIRUNNABLE
  NS_DECL_NSIDOMEVENTLISTENER

  void CancelListener();

 protected:
  virtual ~nsXULPopupShownEvent() = default;

 private:
  const nsCOMPtr<nsIContent> mPopup;
  const RefPtr<nsPresContext> mPresContext;
};

class nsMenuPopupFrame final : public nsBlockFrame {
  using PopupLevel = mozilla::widget::PopupLevel;
  using PopupType = mozilla::widget::PopupType;

 public:
  NS_DECL_QUERYFRAME
  NS_DECL_FRAMEARENA_HELPERS(nsMenuPopupFrame)

  explicit nsMenuPopupFrame(ComputedStyle* aStyle, nsPresContext* aPresContext);
  ~nsMenuPopupFrame();

  // as popups are opened asynchronously, the popup pending state is used to
  // prevent multiple requests from attempting to open the same popup twice
  nsPopupState PopupState() const { return mPopupState; }
  void SetPopupState(nsPopupState);

  /*
   * When this popup is open, should clicks outside of it be consumed?
   * Return true if the popup should rollup on an outside click,
   * but consume that click so it can't be used for anything else.
   * Return false to allow clicks outside the popup to activate content
   * even when the popup is open.
   * ---------------------------------------------------------------------
   *
   * Should clicks outside of a popup be eaten?
   *
   *       Menus     Autocomplete     Comboboxes
   * Mac     Eat           No              Eat
   * Win     No            No              Eat
   * Unix    Eat           No              Eat
   *
   */
  ConsumeOutsideClicksResult ConsumeOutsideClicks();

  mozilla::dom::XULPopupElement& PopupElement() const;

  nscoord GetPrefISize(gfxContext*) final;
  nscoord GetMinISize(gfxContext*) final;
  void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
              const ReflowInput& aReflowInput,
              nsReflowStatus& aStatus) override;

  nsIWidget* GetWidget() const;

  enum class WidgetStyle : uint8_t {
    ColorScheme,
    InputRegion,
    Opacity,
    Shadow,
    Transform,
  };
  using WidgetStyleFlags = mozilla::EnumSet<WidgetStyle>;
  static constexpr WidgetStyleFlags AllWidgetStyleFlags() {
    return {WidgetStyle::ColorScheme, WidgetStyle::InputRegion,
            WidgetStyle::Opacity, WidgetStyle::Shadow, WidgetStyle::Transform};
  }
  void PropagateStyleToWidget(WidgetStyleFlags = AllWidgetStyleFlags()) const;

  // Overridden methods
  void Init(nsIContent* aContent, nsContainerFrame* aParent,
            nsIFrame* aPrevInFlow) override;

  nsresult AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
                            int32_t aModType) override;

  // FIXME: This shouldn't run script (this can end up calling HidePopup).
  MOZ_CAN_RUN_SCRIPT_BOUNDARY void Destroy(DestroyContext&) override;

  bool HasRemoteContent() const;

  // Whether we should create a widget on Init().
  bool ShouldCreateWidgetUpfront() const;

  // Whether we should expand the menu to take the size of the parent menulist.
  bool ShouldExpandToInflowParentOrAnchor() const;

  // Returns true if the popup is a panel with the noautohide attribute set to
  // true. These panels do not roll up automatically.
  bool IsNoAutoHide() const;

  PopupLevel GetPopupLevel() const { return GetPopupLevel(IsNoAutoHide()); }

  // Ensure that a widget has already been created for this view, and create
  // one if it hasn't. If aRecreate is true, destroys any existing widget and
  // creates a new one, regardless of whether one has already been created.
  void PrepareWidget(bool aRecreate = false);

  MOZ_CAN_RUN_SCRIPT void EnsureActiveMenuListItemIsVisible();

  nsresult CreateWidgetForView(nsView* aView);
  mozilla::StyleWindowShadow GetShadowStyle() const;

  void DidSetComputedStyle(ComputedStyle* aOldStyle) override;

  // layout, position and display the popup as needed
  MOZ_CAN_RUN_SCRIPT_BOUNDARY
  void LayoutPopup(nsPresContext*, ReflowOutput&, const ReflowInput&,
                   nsReflowStatus&);

  // Set the position of the popup relative to the anchor content, anchored at a
  // rectangle, or at a specific point if a screen position is set. The popup
  // will be adjusted so that it is on screen. If aIsMove is true, then the
  // popup is being moved, and should not be flipped.
  void SetPopupPosition(bool aIsMove);

  // Called when the Enter key is pressed while the popup is open. This will
  // just pass the call down to the current menu, if any.
  // Also, calling Enter will reset the current incremental search string,
  // calculated in FindMenuWithShortcut.
  MOZ_CAN_RUN_SCRIPT void HandleEnterKeyPress(mozilla::WidgetEvent&);

  // Locate and return the menu frame that should be activated for the supplied
  // key event. If aDoAction is set to true by this method, then the menu's
  // action should be carried out, as if the user had pressed the Enter key. If
  // aDoAction is false, the menu should just be highlighted.
  // This method also handles incremental searching in menus so the user can
  // type the first few letters of an item/s name to select it.
  mozilla::dom::XULButtonElement* FindMenuWithShortcut(
      mozilla::dom::KeyboardEvent& aKeyEvent, bool& aDoAction);

  mozilla::dom::XULButtonElement* GetCurrentMenuItem() const;
  nsIFrame* GetCurrentMenuItemFrame() const;

  PopupType GetPopupType() const { return mPopupType; }
  bool IsContextMenu() const { return mIsContextMenu; }

  bool IsOpen() const {
    return mPopupState == ePopupOpening || mPopupState == ePopupVisible ||
           mPopupState == ePopupShown;
  }
  bool IsVisible() {
    return mPopupState == ePopupVisible || mPopupState == ePopupShown;
  }
  bool IsVisibleOrShowing() {
    return IsOpen() || mPopupState == ePopupPositioning ||
           mPopupState == ePopupShowing;
  }
  bool IsNativeMenu() const { return mIsNativeMenu; }
  bool IsMouseTransparent() const;

  // Return true if the popup is for a menulist.
  bool IsMenuList() const;

  bool IsDragSource() const { return mIsDragSource; }
  void SetIsDragSource(bool aIsDragSource) { mIsDragSource = aIsDragSource; }

  static nsIContent* GetTriggerContent(nsMenuPopupFrame* aMenuPopupFrame);
  void ClearTriggerContent() { mTriggerContent = nullptr; }
  void ClearTriggerContentIncludingDocument();

  // returns true if the popup is in a content shell, or false for a popup in
  // a chrome shell
  bool IsInContentShell() const { return mInContentShell; }

  // the Initialize methods are used to set the anchor position for
  // each way of opening a popup.
  void InitializePopup(nsIContent* aAnchorContent, nsIContent* aTriggerContent,
                       const nsAString& aPosition, int32_t aXPos, int32_t aYPos,
                       MenuPopupAnchorType aAnchorType,
                       bool aAttributesOverride);

  void InitializePopupAtRect(nsIContent* aTriggerContent,
                             const nsAString& aPosition, const nsIntRect& aRect,
                             bool aAttributesOverride);

  /**
   * @param aIsContextMenu if true, then the popup is
   * positioned at a slight offset from aXPos/aYPos to ensure the
   * (presumed) mouse position is not over the menu.
   */
  void InitializePopupAtScreen(nsIContent* aTriggerContent, int32_t aXPos,
                               int32_t aYPos, bool aIsContextMenu);

  // Called if this popup should be displayed as an OS-native context menu.
  void InitializePopupAsNativeContextMenu(nsIContent* aTriggerContent,
                                          int32_t aXPos, int32_t aYPos);

  // indicate that the popup should be opened
  void ShowPopup(bool aIsContextMenu);
  // indicate that the popup should be hidden. The new state should either be
  // ePopupClosed or ePopupInvisible.
  MOZ_CAN_RUN_SCRIPT void HidePopup(bool aDeselectMenu, nsPopupState aNewState,
                                    bool aFromFrameDestruction = false);

  void ClearIncrementalString() { mIncrementalString.Truncate(); }
  static bool IsWithinIncrementalTime(mozilla::TimeStamp time) {
    return !sLastKeyTime.IsNull() &&
           ((time - sLastKeyTime).ToMilliseconds() <=
            mozilla::StaticPrefs::ui_menu_incremental_search_timeout());
  }

#ifdef DEBUG_FRAME_DUMP
  virtual nsresult GetFrameName(nsAString& aResult) const override {
    return MakeFrameName(u"MenuPopup"_ns, aResult);
  }
#endif

  MOZ_CAN_RUN_SCRIPT void ChangeByPage(bool aIsUp);

  // Move the popup to the screen coordinate |aPos| in CSS pixels.
  // If aUpdateAttrs is true, and the popup already has left or top attributes,
  // then those attributes are updated to the new location.
  // The frame may be destroyed by this method.
  void MoveTo(const mozilla::CSSPoint& aPos, bool aUpdateAttrs,
              bool aByMoveToRect = false);

  void MoveToAnchor(nsIContent* aAnchorContent, const nsAString& aPosition,
                    int32_t aXPos, int32_t aYPos, bool aAttributesOverride);

  nsIScrollableFrame* GetScrollFrame() const;

  void SetOverrideConstraintRect(const mozilla::CSSIntRect& aRect) {
    mOverrideConstraintRect = mozilla::CSSIntRect::ToAppUnits(aRect);
  }

  struct Rects {
    // For anchored popups, the anchor rectangle. For non-anchored popups, the
    // size will be 0.
    nsRect mAnchorRect;
    // mAnchorRect before accounting for flipping / resizing / intersecting with
    // the screen. This is needed for Wayland, which flips / resizes at the
    // widget level.
    nsRect mUntransformedAnchorRect;
    // The final used rect we want to occupy.
    nsRect mUsedRect;
    // The alignment offset for sliding the panel, see
    // nsMenuPopupFrame::mAlignmentOffset.
    nscoord mAlignmentOffset = 0;
    bool mHFlip = false;
    bool mVFlip = false;
    // The client offset of our widget.
    mozilla::LayoutDeviceIntPoint mClientOffset;
    nsPoint mViewPoint;
  };

  // For a popup that should appear anchored at the given rect, gets the anchor
  // and constraint rects for that popup.
  // This will be the available area of the screen the popup should be displayed
  // on. Content popups, however, will also be constrained by the content area.
  //
  // For non-toplevel popups (which will always be panels), we will also
  // constrain them to the available screen rect, ie they will not fall
  // underneath the taskbar, dock or other fixed OS elements.
  Rects GetRects(const nsSize& aPrefSize) const;
  Maybe<nsRect> GetConstraintRect(const nsRect& aAnchorRect,
                                  const nsRect& aRootScreenRect,
                                  PopupLevel) const;
  void PerformMove(const Rects&);

  // Return true if the popup is positioned relative to an anchor.
  bool IsAnchored() const { return mAnchorType != MenuPopupAnchorType_Point; }

  // Return the anchor if there is one.
  nsIContent* GetAnchor() const { return mAnchorContent; }

  // Return the screen coordinates in CSS pixels of the popup,
  // or (-1, -1, 0, 0) if anchored.
  mozilla::CSSIntRect GetScreenAnchorRect() const {
    return mozilla::CSSRect::FromAppUnitsRounded(mScreenRect);
  }

  mozilla::LayoutDeviceIntPoint GetLastClientOffset() const {
    return mLastClientOffset;
  }

  // Return the alignment of the popup
  int8_t GetAlignmentPosition() const;

  // Return the offset applied to the alignment of the popup
  nscoord GetAlignmentOffset() const { return mAlignmentOffset; }

  // Clear the mPopupShownDispatcher, remove the listener and return true if
  // mPopupShownDispatcher was non-null.
  bool ClearPopupShownDispatcher() {
    if (mPopupShownDispatcher) {
      mPopupShownDispatcher->CancelListener();
      mPopupShownDispatcher = nullptr;
      return true;
    }

    return false;
  }

  void ShowWithPositionedEvent() { mPopupState = ePopupPositioning; }

  // Checks for the anchor to change and either moves or hides the popup
  // accordingly. The original position of the anchor should be supplied as
  // the argument. If the popup needs to be hidden, HidePopup will be called by
  // CheckForAnchorChange. If the popup needs to be moved, aRect will be updated
  // with the new rectangle.
  void CheckForAnchorChange(nsRect& aRect);

  void WillDispatchPopupPositioned() { mPendingPositionedEvent = false; }

 protected:
  // returns the popup's level.
  PopupLevel GetPopupLevel(bool aIsNoAutoHide) const;
  void TweakMinPrefISize(nscoord&);

  void InitPositionFromAnchorAlign(const nsAString& aAnchor,
                                   const nsAString& aAlign);

  // return the position where the popup should be, when it should be
  // anchored at anchorRect. aHFlip and aVFlip will be set if the popup may be
  // flipped in that direction if there is not enough space available.
  nsPoint AdjustPositionForAnchorAlign(nsRect& aAnchorRect,
                                       const nsSize& aPrefSize,
                                       FlipStyle& aHFlip,
                                       FlipStyle& aVFlip) const;

  // For popups that are going to align to their selected item, get the frame of
  // the selected item.
  nsIFrame* GetSelectedItemForAlignment() const;

  // check if the popup will fit into the available space and resize it. This
  // method handles only one axis at a time so is called twice, once for
  // horizontal and once for vertical. All arguments are specified for this
  // one axis. All coordinates are in app units relative to the screen.
  //   aScreenPoint - the point where the popup should appear
  //   aSize - the size of the popup
  //   aScreenBegin - the left or top edge of the screen
  //   aScreenEnd - the right or bottom edge of the screen
  //   aAnchorBegin - the left or top edge of the anchor rectangle
  //   aAnchorEnd - the right or bottom edge of the anchor rectangle
  //   aMarginBegin - the left or top margin of the popup
  //   aMarginEnd - the right or bottom margin of the popup
  //   aFlip - how to flip or resize the popup when there isn't space
  //   aFlipSide - pointer to where current flip mode is stored
  nscoord FlipOrResize(nscoord& aScreenPoint, nscoord aSize,
                       nscoord aScreenBegin, nscoord aScreenEnd,
                       nscoord aAnchorBegin, nscoord aAnchorEnd,
                       nscoord aMarginBegin, nscoord aMarginEnd,
                       FlipStyle aFlip, bool aIsOnEnd, bool* aFlipSide) const;

  // check if the popup can fit into the available space by "sliding" (i.e.,
  // by having the anchor arrow slide along one axis and only resizing if that
  // can't provide the requested size). Only one axis can be slid - the other
  // axis is "flipped" as normal. This method can handle either axis, but is
  // only called for the sliding axis. All coordinates are in app units
  // relative to the screen.
  //   aScreenPoint - the point where the popup should appear
  //   aSize - the size of the popup
  //   aScreenBegin - the left or top edge of the screen
  //   aScreenEnd - the right or bottom edge of the screen
  //   aOffset - the amount by which the arrow must be slid such that it is
  //             still aligned with the anchor.
  // Result is the new size of the popup, which will typically be the same
  // as aSize, unless aSize is greater than the screen width/height.
  nscoord SlideOrResize(nscoord& aScreenPoint, nscoord aSize,
                        nscoord aScreenBegin, nscoord aScreenEnd,
                        nscoord* aOffset) const;

  // Given an anchor frame, compute the anchor rectangle relative to the screen,
  // using the popup frame's app units, and taking into account transforms.
  nsRect ComputeAnchorRect(nsPresContext* aRootPresContext,
                           nsIFrame* aAnchorFrame) const;

  // Move the popup to the position specified in its |left| and |top|
  // attributes.
  void MoveToAttributePosition();

  // Create a popup view for this frame. The view is added a child of the root
  // view, and is initially hidden.
  void CreatePopupView();

  nsView* GetViewInternal() const override { return mView; }
  void SetViewInternal(nsView* aView) override { mView = aView; }

  // Returns true if the popup should try to remain at the same relative
  // location as the anchor while it is open. If the anchor becomes hidden
  // either directly or indirectly because a parent popup or other element
  // is no longer visible, or a parent deck page is changed, the popup hides
  // as well. The second variation also sets the anchor rectangle, relative to
  // the popup frame.
  bool ShouldFollowAnchor() const;

  nsIFrame* GetAnchorFrame() const;

 public:
  /**
   * Return whether the popup direction should be RTL.
   * If the popup has an anchor, its direction is the anchor direction.
   * Otherwise, its the general direction of the UI.
   *
   * Return whether the popup direction should be RTL.
   */
  bool IsDirectionRTL() const;

  bool ShouldFollowAnchor(nsRect& aRect);

  // Returns parent menu widget for submenus that are in the same
  // frame hierarchy, it's needed for Linux/Wayland which demands
  // strict popup windows hierarchy.
  nsIWidget* GetParentMenuWidget();

  // Returns the effective margin for this popup. This is the CSS margin plus
  // the context-menu shift, if needed.
  nsMargin GetMargin() const;

  // These are used by Wayland backend.
  const nsRect& GetUntransformedAnchorRect() const {
    return mUntransformedAnchorRect;
  }
  int GetPopupAlignment() const { return mPopupAlignment; }
  int GetPopupAnchor() const { return mPopupAnchor; }
  FlipType GetFlipType() const { return mFlip; }
  bool IsFlippedByLayout() const { return mHFlip || mVFlip; }

  void WidgetPositionOrSizeDidChange();

 protected:
  nsString mIncrementalString;  // for incremental typing navigation

  // the content that the popup is anchored to, if any, which may be in a
  // different document than the popup.
  nsCOMPtr<nsIContent> mAnchorContent;

  // the content that triggered the popup, typically the node where the mouse
  // was clicked. It will be cleared when the popup is hidden.
  nsCOMPtr<nsIContent> mTriggerContent;

  nsView* mView = nullptr;

  RefPtr<nsXULPopupShownEvent> mPopupShownDispatcher;

  // The popup's screen rectangle in app units.
  nsRect mUsedScreenRect;

  // A popup's preferred size may be different than its actual size stored in
  // mRect in the case where the popup was resized because it was too large
  // for the screen. The preferred size mPrefSize holds the full size the popup
  // would be before resizing. Computations are performed using this size.
  nsSize mPrefSize{-1, -1};

  // The position of the popup, in CSS pixels.
  // The screen coordinates, if set to values other than -1,
  // override mXPos and mYPos.
  int32_t mXPos = 0;
  int32_t mYPos = 0;
  nsRect mScreenRect;
  // Used for store rectangle which the popup is going to be anchored to, we
  // need that for Wayland. It's important that this rect is unflipped, and
  // without margins applied, as GTK is what takes care of determining how to
  // flip etc. on Wayland.
  nsRect mUntransformedAnchorRect;

  // If the panel prefers to "slide" rather than resize, then the arrow gets
  // positioned at this offset (along either the x or y axis, depending on
  // mPosition)
  nscoord mAlignmentOffset = 0;

  // The value of the client offset of our widget the last time we positioned
  // ourselves. We store this so that we can detect when it changes but the
  // position of our widget didn't change.
  mozilla::LayoutDeviceIntPoint mLastClientOffset;

  PopupType mPopupType = PopupType::Panel;  // type of popup
  nsPopupState mPopupState = ePopupClosed;  // open state of the popup

  // popup alignment relative to the anchor node
  int8_t mPopupAlignment = POPUPALIGNMENT_NONE;
  int8_t mPopupAnchor = POPUPALIGNMENT_NONE;
  int8_t mPosition = POPUPPOSITION_UNKNOWN;

  FlipType mFlip = FlipType_Default;  // Whether to flip

  // Whether we were moved by the move-to-rect Wayland callback. In that case,
  // we stop updating the anchor so that we can end up with a stable position.
  bool mPositionedByMoveToRect = false;
  // true if the open state changed since the last layout.
  bool mIsOpenChanged = false;
  // true for context menus and their submenus.
  bool mIsContextMenu = false;
  // true for the topmost context menu.
  bool mIsTopLevelContextMenu = false;
  // true if the popup is in a content shell.
  bool mInContentShell = true;

  // The flip modes that were used when the popup was opened
  bool mHFlip = false;
  bool mVFlip = false;

  // Whether the most recent initialization of this menupopup happened via
  // InitializePopupAsNativeContextMenu.
  bool mIsNativeMenu = false;

  // Whether we have a pending `popuppositioned` event.
  bool mPendingPositionedEvent = false;

  // Whether this popup is source of D&D operation. We can't close such
  // popup on Wayland as it cancel whole D&D operation.
  bool mIsDragSource = false;

  // When POPUPPOSITION_SELECTION is used, this indicates the vertical offset
  // that the original selected item was. This needs to be used in case the
  // popup gets changed so that we can keep the popup at the same vertical
  // offset.
  // TODO(emilio): try to make this not mutable.
  mutable nscoord mPositionedOffset = 0;

  // How the popup is anchored.
  MenuPopupAnchorType mAnchorType = MenuPopupAnchorType_Node;

  nsRect mOverrideConstraintRect;

  static int8_t sDefaultLevelIsTop;

  static mozilla::TimeStamp sLastKeyTime;

};  // class nsMenuPopupFrame

#endif