The Tor Browser / file revision

 /* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "nsCocoaWindow.h"

 #include "NativeKeyBindings.h"

 #include "TextInputHandler.h"

 #include "nsObjCExceptions.h"

 #include "nsCOMPtr.h"

 #include "nsWidgetsCID.h"

 #include "nsIRollupListener.h"

 #include "nsChildView.h"

 #include "nsWindowMap.h"

 #include "nsAppShell.h"

 #include "nsIAppShellService.h"

 #include "nsIBaseWindow.h"

 #include "nsIInterfaceRequestorUtils.h"

 #include "nsIXULWindow.h"

 #include "nsToolkit.h"

 #include "nsIDOMWindow.h"

 #include "nsPIDOMWindow.h"

 #include "nsIDOMElement.h"

 #include "nsThreadUtils.h"

 #include "nsMenuBarX.h"

 #include "nsMenuUtilsX.h"

 #include "nsStyleConsts.h"

 #include "nsNativeThemeColors.h"

 #include "nsChildView.h"

 #include "nsCocoaFeatures.h"

 #include "nsIScreenManager.h"

 #include "nsIWidgetListener.h"

 #include "nsIPresShell.h"

 #include "gfxPlatform.h"

 #include "qcms.h"

 #include "mozilla/AutoRestore.h"

 #include "mozilla/BasicEvents.h"

 #include "mozilla/Preferences.h"

 #include <algorithm>

 namespace mozilla {

 namespace layers {

 class LayerManager;

 }

 }

 using namespace mozilla::layers;

 using namespace mozilla::widget;

 using namespace mozilla;

 // defined in nsAppShell.mm

 extern nsCocoaAppModalWindowList *gCocoaAppModalWindowList;

 int32_t gXULModalLevel = 0;

 // In principle there should be only one app-modal window at any given time.

 // But sometimes, despite our best efforts, another window appears above the

 // current app-modal window.  So we need to keep a linked list of app-modal

 // windows.  (A non-sheet window that appears above an app-modal window is

 // also made app-modal.)  See nsCocoaWindow::SetModal().

 nsCocoaWindowList *gGeckoAppModalWindowList = NULL;

 // defined in nsMenuBarX.mm

 extern NSMenu* sApplicationMenu; // Application menu shared by all menubars

 // defined in nsChildView.mm

 extern BOOL                gSomeMenuBarPainted;

 extern "C" {

   // CGSPrivate.h

   typedef NSInteger CGSConnection;

   typedef NSInteger CGSWindow;

   typedef NSUInteger CGSWindowFilterRef;

   extern CGSConnection _CGSDefaultConnection(void);

   extern CGError CGSSetWindowShadowAndRimParameters(const CGSConnection cid, CGSWindow wid, float standardDeviation, float density, int offsetX, int offsetY, unsigned int flags);

   extern CGError CGSSetWindowBackgroundBlurRadius(CGSConnection cid, CGSWindow wid, NSUInteger blur);

 }

 #define NS_APPSHELLSERVICE_CONTRACTID "@mozilla.org/appshell/appShellService;1"

 NS_IMPL_ISUPPORTS_INHERITED(nsCocoaWindow, Inherited, nsPIWidgetCocoa)

 // A note on testing to see if your object is a sheet...

 // |mWindowType == eWindowType_sheet| is true if your gecko nsIWidget is a sheet

 // widget - whether or not the sheet is showing. |[mWindow isSheet]| will return

 // true *only when the sheet is actually showing*. Choose your test wisely.

 static void RollUpPopups()

 {

   nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener();

   NS_ENSURE_TRUE_VOID(rollupListener);

   nsCOMPtr<nsIWidget> rollupWidget = rollupListener->GetRollupWidget();

   if (!rollupWidget)

     return;

   rollupListener->Rollup(0, nullptr, nullptr);

 }

 nsCocoaWindow::nsCocoaWindow()

 : mParent(nullptr)

 , mWindow(nil)

 , mDelegate(nil)

 , mSheetWindowParent(nil)

 , mPopupContentView(nil)

 , mShadowStyle(NS_STYLE_WINDOW_SHADOW_DEFAULT)

 , mBackingScaleFactor(0.0)

 , mAnimationType(nsIWidget::eGenericWindowAnimation)

 , mWindowMadeHere(false)

 , mSheetNeedsShow(false)

 , mFullScreen(false)

 , mInFullScreenTransition(false)

 , mModal(false)

 , mUsesNativeFullScreen(false)

 , mIsAnimationSuppressed(false)

 , mInReportMoveEvent(false)

 , mInResize(false)

 , mNumModalDescendents(0)

 {

 }

 void nsCocoaWindow::DestroyNativeWindow()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (!mWindow)

     return;

   // We want to unhook the delegate here because we don't want events

   // sent to it after this object has been destroyed.

   [mWindow setDelegate:nil];

   [mWindow close];

   mWindow = nil;

   [mDelegate autorelease];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 nsCocoaWindow::~nsCocoaWindow()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   // Notify the children that we're gone.  Popup windows (e.g. tooltips) can

   // have nsChildView children.  'kid' is an nsChildView object if and only if

   // its 'type' is 'eWindowType_child' or 'eWindowType_plugin'.

   // childView->ResetParent() can change our list of children while it's

   // being iterated, so the way we iterate the list must allow for this.

   for (nsIWidget* kid = mLastChild; kid;) {

     nsWindowType kidType = kid->WindowType();

     if (kidType == eWindowType_child || kidType == eWindowType_plugin) {

       nsChildView* childView = static_cast<nsChildView*>(kid);

       kid = kid->GetPrevSibling();

       childView->ResetParent();

     } else {

       nsCocoaWindow* childWindow = static_cast<nsCocoaWindow*>(kid);

       childWindow->mParent = nullptr;

       kid = kid->GetPrevSibling();

     }

   }

   if (mWindow && mWindowMadeHere) {

     DestroyNativeWindow();

   }

   NS_IF_RELEASE(mPopupContentView);

   // Deal with the possiblity that we're being destroyed while running modal.

   if (mModal) {

     NS_WARNING("Widget destroyed while running modal!");

     --gXULModalLevel;

     NS_ASSERTION(gXULModalLevel >= 0, "Wierdness setting modality!");

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 // Find the screen that overlaps aRect the most,

 // if none are found default to the mainScreen.

 static NSScreen *FindTargetScreenForRect(const nsIntRect& aRect)

 {

   NSScreen *targetScreen = [NSScreen mainScreen];

   NSEnumerator *screenEnum = [[NSScreen screens] objectEnumerator];

   int largestIntersectArea = 0;

   while (NSScreen *screen = [screenEnum nextObject]) {

     nsIntRect screenRect(nsCocoaUtils::CocoaRectToGeckoRect([screen visibleFrame]));

     screenRect = screenRect.Intersect(aRect);

     int area = screenRect.width * screenRect.height;

     if (area > largestIntersectArea) {

       largestIntersectArea = area;

       targetScreen = screen;

     }

   }

   return targetScreen;

 }

 // fits the rect to the screen that contains the largest area of it,

 // or to aScreen if a screen is passed in

 // NB: this operates with aRect in global display pixels

 static void FitRectToVisibleAreaForScreen(nsIntRect &aRect, NSScreen *aScreen,

                                           bool aUsesNativeFullScreen)

 {

   if (!aScreen) {

     aScreen = FindTargetScreenForRect(aRect);

   }

   nsIntRect screenBounds(nsCocoaUtils::CocoaRectToGeckoRect([aScreen visibleFrame]));

   if (aRect.width > screenBounds.width) {

     aRect.width = screenBounds.width;

   }

   if (aRect.height > screenBounds.height) {

     aRect.height = screenBounds.height;

   }

   if (aRect.x - screenBounds.x + aRect.width > screenBounds.width) {

     aRect.x += screenBounds.width - (aRect.x - screenBounds.x + aRect.width);

   }

   if (aRect.y - screenBounds.y + aRect.height > screenBounds.height) {

     aRect.y += screenBounds.height - (aRect.y - screenBounds.y + aRect.height);

   }

   // If the left/top edge of the window is off the screen in either direction,

   // then set the window to start at the left/top edge of the screen.

   if (aRect.x < screenBounds.x || aRect.x > (screenBounds.x + screenBounds.width)) {

     aRect.x = screenBounds.x;

   }

   if (aRect.y < screenBounds.y || aRect.y > (screenBounds.y + screenBounds.height)) {

     aRect.y = screenBounds.y;

   }

   // If aRect is filling the screen and the window supports native (Lion-style)

   // fullscreen mode, reduce aRect's height and shift it down by 22 pixels

   // (nominally the height of the menu bar or of a window's title bar).  For

   // some reason this works around bug 740923.  Yes, it's a bodacious hack.

   // But until we know more it will have to do.

   if (aUsesNativeFullScreen && aRect.y == 0 && aRect.height == screenBounds.height) {

     aRect.y = 22;

     aRect.height -= 22;

   }

 }

 // Some applications like Camino use native popup windows

 // (native context menus, native tooltips)

 static bool UseNativePopupWindows()

 {

 #ifdef MOZ_USE_NATIVE_POPUP_WINDOWS

   return true;

 #else

   return false;

 #endif /* MOZ_USE_NATIVE_POPUP_WINDOWS */

 }

 // aRect here is specified in global display pixels

 nsresult nsCocoaWindow::Create(nsIWidget *aParent,

                                nsNativeWidget aNativeParent,

                                const nsIntRect &aRect,

                                nsDeviceContext *aContext,

                                nsWidgetInitData *aInitData)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   // Because the hidden window is created outside of an event loop,

   // we have to provide an autorelease pool (see bug 559075).

   nsAutoreleasePool localPool;

   nsIntRect newBounds = aRect;

   FitRectToVisibleAreaForScreen(newBounds, nullptr, mUsesNativeFullScreen);

   // Set defaults which can be overriden from aInitData in BaseCreate

   mWindowType = eWindowType_toplevel;

   mBorderStyle = eBorderStyle_default;

   // Ensure that the toolkit is created.

   nsToolkit::GetToolkit();

   // newBounds is still display (global screen) pixels at this point;

   // fortunately, BaseCreate doesn't actually use it so we don't

   // need to worry about trying to convert it to device pixels

   // when we don't have a window (or dev context, perhaps) yet

   Inherited::BaseCreate(aParent, newBounds, aContext, aInitData);

   mParent = aParent;

   // Applications that use native popups don't want us to create popup windows.

   if ((mWindowType == eWindowType_popup) && UseNativePopupWindows())

     return NS_OK;

   nsresult rv =

     CreateNativeWindow(nsCocoaUtils::GeckoRectToCocoaRect(newBounds),

                        mBorderStyle, false);

   NS_ENSURE_SUCCESS(rv, rv);

   if (mWindowType == eWindowType_popup) {

     if (aInitData->mMouseTransparent) {

       [mWindow setIgnoresMouseEvents:YES];

     }

     // now we can convert newBounds to device pixels for the window we created,

     // as the child view expects a rect expressed in the dev pix of its parent

     double scale = BackingScaleFactor();

     newBounds.x *= scale;

     newBounds.y *= scale;

     newBounds.width *= scale;

     newBounds.height *= scale;

     return CreatePopupContentView(newBounds, aContext);

   }

   mIsAnimationSuppressed = aInitData->mIsAnimationSuppressed;

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 static unsigned int WindowMaskForBorderStyle(nsBorderStyle aBorderStyle)

 {

   bool allOrDefault = (aBorderStyle == eBorderStyle_all ||

                          aBorderStyle == eBorderStyle_default);

   /* Apple's docs on NSWindow styles say that "a window's style mask should

    * include NSTitledWindowMask if it includes any of the others [besides

    * NSBorderlessWindowMask]".  This implies that a borderless window

    * shouldn't have any other styles than NSBorderlessWindowMask.

    */

   if (!allOrDefault && !(aBorderStyle & eBorderStyle_title))

     return NSBorderlessWindowMask;

   unsigned int mask = NSTitledWindowMask;

   if (allOrDefault || aBorderStyle & eBorderStyle_close)

     mask |= NSClosableWindowMask;

   if (allOrDefault || aBorderStyle & eBorderStyle_minimize)

     mask |= NSMiniaturizableWindowMask;

   if (allOrDefault || aBorderStyle & eBorderStyle_resizeh)

     mask |= NSResizableWindowMask;

   return mask;

 }

 NS_IMETHODIMP nsCocoaWindow::ReparentNativeWidget(nsIWidget* aNewParent)

 {

   return NS_ERROR_NOT_IMPLEMENTED;

 }

 // If aRectIsFrameRect, aRect specifies the frame rect of the new window.

 // Otherwise, aRect.x/y specify the position of the window's frame relative to

 // the bottom of the menubar and aRect.width/height specify the size of the

 // content rect.

 nsresult nsCocoaWindow::CreateNativeWindow(const NSRect &aRect,

                                            nsBorderStyle aBorderStyle,

                                            bool aRectIsFrameRect)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   // We default to NSBorderlessWindowMask, add features if needed.

   unsigned int features = NSBorderlessWindowMask;

   // Configure the window we will create based on the window type.

   switch (mWindowType)

   {

     case eWindowType_invisible:

     case eWindowType_child:

     case eWindowType_plugin:

       break;

     case eWindowType_popup:

       if (aBorderStyle != eBorderStyle_default && mBorderStyle & eBorderStyle_title) {

         features |= NSTitledWindowMask;

         if (aBorderStyle & eBorderStyle_close) {

           features |= NSClosableWindowMask;

         }

       }

       break;

     case eWindowType_toplevel:

     case eWindowType_dialog:

       features = WindowMaskForBorderStyle(aBorderStyle);

       break;

     case eWindowType_sheet:

       if (mParent->WindowType() != eWindowType_invisible &&

           aBorderStyle & eBorderStyle_resizeh) {

         features = NSResizableWindowMask;

       }

       else {

         features = NSMiniaturizableWindowMask;

       }

       features |= NSTitledWindowMask;

       break;

     default:

       NS_ERROR("Unhandled window type!");

       return NS_ERROR_FAILURE;

   }

   NSRect contentRect;

   if (aRectIsFrameRect) {

     contentRect = [NSWindow contentRectForFrameRect:aRect styleMask:features];

   } else {

     /* 

      * We pass a content area rect to initialize the native Cocoa window. The

      * content rect we give is the same size as the size we're given by gecko.

      * The origin we're given for non-popup windows is moved down by the height

      * of the menu bar so that an origin of (0,100) from gecko puts the window

      * 100 pixels below the top of the available desktop area. We also move the

      * origin down by the height of a title bar if it exists. This is so the

      * origin that gecko gives us for the top-left of  the window turns out to

      * be the top-left of the window we create. This is how it was done in

      * Carbon. If it ought to be different we'll probably need to look at all

      * the callers.

      *

      * Note: This means that if you put a secondary screen on top of your main

      * screen and open a window in the top screen, it'll be incorrectly shifted

      * down by the height of the menu bar. Same thing would happen in Carbon.

      *

      * Note: If you pass a rect with 0,0 for an origin, the window ends up in a

      * weird place for some reason. This stops that without breaking popups.

      */

     // Compensate for difference between frame and content area height (e.g. title bar).

     NSRect newWindowFrame = [NSWindow frameRectForContentRect:aRect styleMask:features];

     contentRect = aRect;

     contentRect.origin.y -= (newWindowFrame.size.height - aRect.size.height);

     if (mWindowType != eWindowType_popup)

       contentRect.origin.y -= [[NSApp mainMenu] menuBarHeight];

   }

   // NSLog(@"Top-level window being created at Cocoa rect: %f, %f, %f, %f\n",

   //       rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);

   Class windowClass = [BaseWindow class];

   // If we have a titlebar on a top-level window, we want to be able to control the 

   // titlebar color (for unified windows), so use the special ToolbarWindow class. 

   // Note that we need to check the window type because we mark sheets as 

   // having titlebars.

   if ((mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog) &&

       (features & NSTitledWindowMask))

     windowClass = [ToolbarWindow class];

   // If we're a popup window we need to use the PopupWindow class.

   else if (mWindowType == eWindowType_popup)

     windowClass = [PopupWindow class];

   // If we're a non-popup borderless window we need to use the

   // BorderlessWindow class.

   else if (features == NSBorderlessWindowMask)

     windowClass = [BorderlessWindow class];

   // Create the window

   mWindow = [[windowClass alloc] initWithContentRect:contentRect styleMask:features 

                                  backing:NSBackingStoreBuffered defer:YES];

   // setup our notification delegate. Note that setDelegate: does NOT retain.

   mDelegate = [[WindowDelegate alloc] initWithGeckoWindow:this];

   [mWindow setDelegate:mDelegate];

   // Make sure that the content rect we gave has been honored.

   NSRect wantedFrame = [mWindow frameRectForContentRect:contentRect];

   if (!NSEqualRects([mWindow frame], wantedFrame)) {

     // This can happen when the window is not on the primary screen.

     [mWindow setFrame:wantedFrame display:NO];

   }

   UpdateBounds();

   if (mWindowType == eWindowType_invisible) {

     [mWindow setLevel:kCGDesktopWindowLevelKey];

   } else if (mWindowType == eWindowType_popup) {

     SetPopupWindowLevel();

     [mWindow setHasShadow:YES];

   }

   [mWindow setBackgroundColor:[NSColor clearColor]];

 #ifdef MOZ_B2G

   // In B2G, we don't create popups and we need OMTC to work (because out of

   // process compositing depends on it). Therefore, we don't need our windows

   // to be transparent.

   [mWindow setOpaque:YES];

 #else

   [mWindow setOpaque:NO];

 #endif

   [mWindow setContentMinSize:NSMakeSize(60, 60)];

   [mWindow disableCursorRects];

   // Make sure the window starts out not draggable by the background.

   // We will turn it on as necessary.

   [mWindow setMovableByWindowBackground:NO];

   [[WindowDataMap sharedWindowDataMap] ensureDataForWindow:mWindow];

   mWindowMadeHere = true;

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 NS_IMETHODIMP nsCocoaWindow::CreatePopupContentView(const nsIntRect &aRect,

                              nsDeviceContext *aContext)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   // We need to make our content view a ChildView.

   mPopupContentView = new nsChildView();

   if (!mPopupContentView)

     return NS_ERROR_FAILURE;

   NS_ADDREF(mPopupContentView);

   nsIWidget* thisAsWidget = static_cast<nsIWidget*>(this);

   mPopupContentView->Create(thisAsWidget, nullptr, aRect, aContext, nullptr);

   ChildView* newContentView = (ChildView*)mPopupContentView->GetNativeData(NS_NATIVE_WIDGET);

   [mWindow setContentView:newContentView];

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 NS_IMETHODIMP nsCocoaWindow::Destroy()

 {

   // If we don't hide here we run into problems with panels, this is not ideal.

   // (Bug 891424)

   Show(false);

   if (mPopupContentView)

     mPopupContentView->Destroy();

   nsBaseWidget::Destroy();

   // nsBaseWidget::Destroy() calls GetParent()->RemoveChild(this). But we

   // don't implement GetParent(), so we need to do the equivalent here.

   if (mParent) {

     mParent->RemoveChild(this);

   }

   nsBaseWidget::OnDestroy();

   if (mFullScreen) {

     // On Lion we don't have to mess with the OS chrome when in Full Screen

     // mode.  But we do have to destroy the native window here (and not wait

     // for that to happen in our destructor).  We don't switch away from the

     // native window's space until the window is destroyed, and otherwise this

     // might not happen for several seconds (because at least one object

     // holding a reference to ourselves is usually waiting to be garbage-

     // collected).  See bug 757618.

     if (mUsesNativeFullScreen) {

       DestroyNativeWindow();

     } else if (mWindow) {

       nsCocoaUtils::HideOSChromeOnScreen(false, [mWindow screen]);

     }

   }

   return NS_OK;

 }

 nsIWidget* nsCocoaWindow::GetSheetWindowParent(void)

 {

   if (mWindowType != eWindowType_sheet)

     return nullptr;

   nsCocoaWindow *parent = static_cast<nsCocoaWindow*>(mParent);

   while (parent && (parent->mWindowType == eWindowType_sheet))

     parent = static_cast<nsCocoaWindow*>(parent->mParent);

   return parent;

 }

 void* nsCocoaWindow::GetNativeData(uint32_t aDataType)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSNULL;

   void* retVal = nullptr;

   switch (aDataType) {

     // to emulate how windows works, we always have to return a NSView

     // for NS_NATIVE_WIDGET

     case NS_NATIVE_WIDGET:

     case NS_NATIVE_DISPLAY:

       retVal = [mWindow contentView];

       break;

     case NS_NATIVE_WINDOW:

       retVal = mWindow;

       break;

     case NS_NATIVE_GRAPHIC:

       // There isn't anything that makes sense to return here,

       // and it doesn't matter so just return nullptr.

       NS_ERROR("Requesting NS_NATIVE_GRAPHIC on a top-level window!");

       break;

   }

   return retVal;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSNULL;

 }

 bool nsCocoaWindow::IsVisible() const

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;

   return (mWindow && ([mWindow isVisibleOrBeingShown] || mSheetNeedsShow));

   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false);

 }

 NS_IMETHODIMP nsCocoaWindow::SetModal(bool aState)

 {

   if (!mWindow)

     return NS_OK;

   // This is used during startup (outside the event loop) when creating

   // the add-ons compatibility checking dialog and the profile manager UI;

   // therefore, it needs to provide an autorelease pool to avoid cocoa

   // objects leaking.

   nsAutoreleasePool localPool;

   mModal = aState;

   nsCocoaWindow *aParent = static_cast<nsCocoaWindow*>(mParent);

   if (aState) {

     ++gXULModalLevel;

     if (gCocoaAppModalWindowList)

       gCocoaAppModalWindowList->PushGecko(mWindow, this);

     // When a non-sheet window gets "set modal", make the window(s) that it

     // appears over behave as they should.  We can't rely on native methods to

     // do this, for the following reason:  The OS runs modal non-sheet windows

     // in an event loop (using [NSApplication runModalForWindow:] or similar

     // methods) that's incompatible with the modal event loop in nsXULWindow::

     // ShowModal() (each of these event loops is "exclusive", and can't run at

     // the same time as other (similar) event loops).

     if (mWindowType != eWindowType_sheet) {

       while (aParent) {

         if (aParent->mNumModalDescendents++ == 0) {

           NSWindow *aWindow = aParent->GetCocoaWindow();

           if (aParent->mWindowType != eWindowType_invisible) {

             [[aWindow standardWindowButton:NSWindowCloseButton] setEnabled:NO];

             [[aWindow standardWindowButton:NSWindowMiniaturizeButton] setEnabled:NO];

             [[aWindow standardWindowButton:NSWindowZoomButton] setEnabled:NO];

           }

         }

         aParent = static_cast<nsCocoaWindow*>(aParent->mParent);

       }

       [mWindow setLevel:NSModalPanelWindowLevel];

       nsCocoaWindowList *windowList = new nsCocoaWindowList;

       if (windowList) {

         windowList->window = this; // Don't ADDREF

         windowList->prev = gGeckoAppModalWindowList;

         gGeckoAppModalWindowList = windowList;

       }

     }

   }

   else {

     --gXULModalLevel;

     NS_ASSERTION(gXULModalLevel >= 0, "Mismatched call to nsCocoaWindow::SetModal(false)!");

     if (gCocoaAppModalWindowList)

       gCocoaAppModalWindowList->PopGecko(mWindow, this);

     if (mWindowType != eWindowType_sheet) {

       while (aParent) {

         if (--aParent->mNumModalDescendents == 0) {

           NSWindow *aWindow = aParent->GetCocoaWindow();

           if (aParent->mWindowType != eWindowType_invisible) {

             [[aWindow standardWindowButton:NSWindowCloseButton] setEnabled:YES];

             [[aWindow standardWindowButton:NSWindowMiniaturizeButton] setEnabled:YES];

             [[aWindow standardWindowButton:NSWindowZoomButton] setEnabled:YES];

           }

         }

         NS_ASSERTION(aParent->mNumModalDescendents >= 0, "Widget hierarchy changed while modal!");

         aParent = static_cast<nsCocoaWindow*>(aParent->mParent);

       }

       if (gGeckoAppModalWindowList) {

         NS_ASSERTION(gGeckoAppModalWindowList->window == this, "Widget hierarchy changed while modal!");

         nsCocoaWindowList *saved = gGeckoAppModalWindowList;

         gGeckoAppModalWindowList = gGeckoAppModalWindowList->prev;

         delete saved; // "window" not ADDREFed

       }

       if (mWindowType == eWindowType_popup)

         SetPopupWindowLevel();

       else

         [mWindow setLevel:NSNormalWindowLevel];

     }

   }

   return NS_OK;

 }

 // Hide or show this window

 NS_IMETHODIMP nsCocoaWindow::Show(bool bState)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow)

     return NS_OK;

   // We need to re-execute sometimes in order to bring already-visible

   // windows forward.

   if (!mSheetNeedsShow && !bState && ![mWindow isVisible])

     return NS_OK;

   // Protect against re-entering.

   if (bState && [mWindow isBeingShown])

     return NS_OK;

   [mWindow setBeingShown:bState];

   nsIWidget* parentWidget = mParent;

   nsCOMPtr<nsPIWidgetCocoa> piParentWidget(do_QueryInterface(parentWidget));

   NSWindow* nativeParentWindow = (parentWidget) ?

     (NSWindow*)parentWidget->GetNativeData(NS_NATIVE_WINDOW) : nil;

   if (bState && !mBounds.IsEmpty()) {

     if (mPopupContentView) {

       // Ensure our content view is visible. We never need to hide it.

       mPopupContentView->Show(true);

     }

     if (mWindowType == eWindowType_sheet) {

       // bail if no parent window (its basically what we do in Carbon)

       if (!nativeParentWindow || !piParentWidget)

         return NS_ERROR_FAILURE;

       NSWindow* topNonSheetWindow = nativeParentWindow;

       // If this sheet is the child of another sheet, hide the parent so that

       // this sheet can be displayed. Leave the parent mSheetNeedsShow alone,

       // that is only used to handle sibling sheet contention. The parent will

       // return once there are no more child sheets.

       bool parentIsSheet = false;

       if (NS_SUCCEEDED(piParentWidget->GetIsSheet(&parentIsSheet)) &&

           parentIsSheet) {

         piParentWidget->GetSheetWindowParent(&topNonSheetWindow);

         [NSApp endSheet:nativeParentWindow];

       }

       nsCocoaWindow* sheetShown = nullptr;

       if (NS_SUCCEEDED(piParentWidget->GetChildSheet(true, &sheetShown)) &&

           (!sheetShown || sheetShown == this)) {

         // If this sheet is already the sheet actually being shown, don't

         // tell it to show again. Otherwise the number of calls to

         // [NSApp beginSheet...] won't match up with [NSApp endSheet...].

         if (![mWindow isVisible]) {

           mSheetNeedsShow = false;

           mSheetWindowParent = topNonSheetWindow;

           // Only set contextInfo if our parent isn't a sheet.

           NSWindow* contextInfo = parentIsSheet ? nil : mSheetWindowParent;

           [TopLevelWindowData deactivateInWindow:mSheetWindowParent];

           [NSApp beginSheet:mWindow

              modalForWindow:mSheetWindowParent

               modalDelegate:mDelegate

              didEndSelector:@selector(didEndSheet:returnCode:contextInfo:)

                 contextInfo:contextInfo];

           [TopLevelWindowData activateInWindow:mWindow];

           SendSetZLevelEvent();

         }

       }

       else {

         // A sibling of this sheet is active, don't show this sheet yet.

         // When the active sheet hides, its brothers and sisters that have

         // mSheetNeedsShow set will have their opportunities to display.

         mSheetNeedsShow = true;

       }

     }

     else if (mWindowType == eWindowType_popup) {

       // If a popup window is shown after being hidden, it needs to be "reset"

       // for it to receive any mouse events aside from mouse-moved events

       // (because it was removed from the "window cache" when it was hidden

       // -- see below).  Setting the window number to -1 and then back to its

       // original value seems to accomplish this.  The idea was "borrowed"

       // from the Java Embedding Plugin.

       NSInteger windowNumber = [mWindow windowNumber];

       [mWindow _setWindowNumber:-1];

       [mWindow _setWindowNumber:windowNumber];

       // For reasons that aren't yet clear, calls to [NSWindow orderFront:] or

       // [NSWindow makeKeyAndOrderFront:] can sometimes trigger "Error (1000)

       // creating CGSWindow", which in turn triggers an internal inconsistency

       // NSException.  These errors shouldn't be fatal.  So we need to wrap

       // calls to ...orderFront: in LOGONLY blocks.  See bmo bug 470864.

       NS_OBJC_BEGIN_TRY_LOGONLY_BLOCK;

       [[mWindow contentView] setNeedsDisplay:YES];

       [mWindow orderFront:nil];

       NS_OBJC_END_TRY_LOGONLY_BLOCK;

       SendSetZLevelEvent();

       AdjustWindowShadow();

       SetWindowBackgroundBlur();

       // If our popup window is a non-native context menu, tell the OS (and

       // other programs) that a menu has opened.  This is how the OS knows to

       // close other programs' context menus when ours open.

       if ([mWindow isKindOfClass:[PopupWindow class]] &&

           [(PopupWindow*) mWindow isContextMenu]) {

         [[NSDistributedNotificationCenter defaultCenter]

           postNotificationName:@"com.apple.HIToolbox.beginMenuTrackingNotification"

                         object:@"org.mozilla.gecko.PopupWindow"];

       }

       // If a parent window was supplied and this is a popup at the parent

       // level, set its child window. This will cause the child window to

       // appear above the parent and move when the parent does. Setting this

       // needs to happen after the _setWindowNumber calls above, otherwise the

       // window doesn't focus properly.

       if (nativeParentWindow && mPopupLevel == ePopupLevelParent)

         [nativeParentWindow addChildWindow:mWindow

                             ordered:NSWindowAbove];

     }

     else {

       NS_OBJC_BEGIN_TRY_LOGONLY_BLOCK;

       if (mWindowType == eWindowType_toplevel &&

           [mWindow respondsToSelector:@selector(setAnimationBehavior:)]) {

         NSWindowAnimationBehavior behavior;

         if (mIsAnimationSuppressed) {

           behavior = NSWindowAnimationBehaviorNone;

         } else {

           switch (mAnimationType) {

             case nsIWidget::eDocumentWindowAnimation:

               behavior = NSWindowAnimationBehaviorDocumentWindow;

               break;

             default:

               NS_NOTREACHED("unexpected mAnimationType value");

               // fall through

             case nsIWidget::eGenericWindowAnimation:

               behavior = NSWindowAnimationBehaviorDefault;

               break;

           }

         }

         [mWindow setAnimationBehavior:behavior];

       }

       [mWindow makeKeyAndOrderFront:nil];

       NS_OBJC_END_TRY_LOGONLY_BLOCK;

       SendSetZLevelEvent();

     }

   }

   else {

     // roll up any popups if a top-level window is going away

     if (mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog)

       RollUpPopups();

     // now get rid of the window/sheet

     if (mWindowType == eWindowType_sheet) {

       if (mSheetNeedsShow) {

         // This is an attempt to hide a sheet that never had a chance to

         // be shown. There's nothing to do other than make sure that it

         // won't show.

         mSheetNeedsShow = false;

       }

       else {

         // get sheet's parent *before* hiding the sheet (which breaks the linkage)

         NSWindow* sheetParent = mSheetWindowParent;

         // hide the sheet

         [NSApp endSheet:mWindow];

         [TopLevelWindowData deactivateInWindow:mWindow];

         nsCocoaWindow* siblingSheetToShow = nullptr;

         bool parentIsSheet = false;

         if (nativeParentWindow && piParentWidget &&

             NS_SUCCEEDED(piParentWidget->GetChildSheet(false, &siblingSheetToShow)) &&

             siblingSheetToShow) {

           // First, give sibling sheets an opportunity to show.

           siblingSheetToShow->Show(true);

         }

         else if (nativeParentWindow && piParentWidget &&

                  NS_SUCCEEDED(piParentWidget->GetIsSheet(&parentIsSheet)) &&

                  parentIsSheet) {

           // Only set contextInfo if the parent of the parent sheet we're about

           // to restore isn't itself a sheet.

           NSWindow* contextInfo = sheetParent;

           nsIWidget* grandparentWidget = nil;

           if (NS_SUCCEEDED(piParentWidget->GetRealParent(&grandparentWidget)) && grandparentWidget) {

             nsCOMPtr<nsPIWidgetCocoa> piGrandparentWidget(do_QueryInterface(grandparentWidget));

             bool grandparentIsSheet = false;

             if (piGrandparentWidget && NS_SUCCEEDED(piGrandparentWidget->GetIsSheet(&grandparentIsSheet)) &&

                 grandparentIsSheet) {

                 contextInfo = nil;

             }

           }

           // If there are no sibling sheets, but the parent is a sheet, restore

           // it.  It wasn't sent any deactivate events when it was hidden, so

           // don't call through Show, just let the OS put it back up.

           [NSApp beginSheet:nativeParentWindow

              modalForWindow:sheetParent

               modalDelegate:[nativeParentWindow delegate]

              didEndSelector:@selector(didEndSheet:returnCode:contextInfo:)

                 contextInfo:contextInfo];

         }

         else {

           // Sheet, that was hard.  No more siblings or parents, going back

           // to a real window.

           NS_OBJC_BEGIN_TRY_LOGONLY_BLOCK;

           [sheetParent makeKeyAndOrderFront:nil];

           NS_OBJC_END_TRY_LOGONLY_BLOCK;

         }

         SendSetZLevelEvent();

       }

     }

     else {

       // If the window is a popup window with a parent window we need to

       // unhook it here before ordering it out. When you order out the child

       // of a window it hides the parent window.

       if (mWindowType == eWindowType_popup && nativeParentWindow)

         [nativeParentWindow removeChildWindow:mWindow];

       [mWindow orderOut:nil];

       // Unless it's explicitly removed from NSApp's "window cache", a popup

       // window will keep receiving mouse-moved events even after it's been

       // "ordered out" (instead of the browser window that was underneath it,

       // until you click on that window).  This is bmo bug 378645, but it's

       // surely an Apple bug.  The "window cache" is an undocumented subsystem,

       // all of whose methods are included in the NSWindowCache category of

       // the NSApplication class (in header files generated using class-dump).

       // This workaround was "borrowed" from the Java Embedding Plugin (which

       // uses it for a different purpose).

       if (mWindowType == eWindowType_popup)

         [NSApp _removeWindowFromCache:mWindow];

       // If our popup window is a non-native context menu, tell the OS (and

       // other programs) that a menu has closed.

       if ([mWindow isKindOfClass:[PopupWindow class]] &&

           [(PopupWindow*) mWindow isContextMenu]) {

         [[NSDistributedNotificationCenter defaultCenter]

           postNotificationName:@"com.apple.HIToolbox.endMenuTrackingNotification"

                         object:@"org.mozilla.gecko.PopupWindow"];

       }

     }

   }

   [mWindow setBeingShown:NO];

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 struct ShadowParams {

   float standardDeviation;

   float density;

   int offsetX;

   int offsetY;

   unsigned int flags;

 };

 // These numbers have been determined by looking at the results of

 // CGSGetWindowShadowAndRimParameters for native window types.

 static const ShadowParams kWindowShadowParameters[] = {

   { 0.0f, 0.0f, 0, 0, 0 },        // none

   { 8.0f, 0.5f, 0, 6, 1 },        // default

   { 10.0f, 0.44f, 0, 10, 512 },   // menu

   { 8.0f, 0.5f, 0, 6, 1 },        // tooltip

   { 4.0f, 0.6f, 0, 4, 512 }       // sheet

 };

 // This method will adjust the window shadow style for popup windows after

 // they have been made visible. Before they're visible, their window number

 // might be -1, which is not useful.

 // We won't attempt to change the shadow for windows that can acquire key state

 // since OS X will reset the shadow whenever that happens.

 void

 nsCocoaWindow::AdjustWindowShadow()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (!mWindow || ![mWindow isVisible] || ![mWindow hasShadow] ||

       [mWindow canBecomeKeyWindow] || [mWindow windowNumber] == -1)

     return;

   const ShadowParams& params = kWindowShadowParameters[mShadowStyle];

   CGSConnection cid = _CGSDefaultConnection();

   CGSSetWindowShadowAndRimParameters(cid, [mWindow windowNumber],

                                      params.standardDeviation, params.density,

                                      params.offsetX, params.offsetY,

                                      params.flags);

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 static const NSUInteger kWindowBackgroundBlurRadius = 4;

 void

 nsCocoaWindow::SetWindowBackgroundBlur()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (!mWindow || ![mWindow isVisible] || [mWindow windowNumber] == -1)

     return;

   // Only blur the background of menus and fake sheets.

   if (mShadowStyle != NS_STYLE_WINDOW_SHADOW_MENU &&

       mShadowStyle != NS_STYLE_WINDOW_SHADOW_SHEET)

     return;

   CGSConnection cid = _CGSDefaultConnection();

   CGSSetWindowBackgroundBlurRadius(cid, [mWindow windowNumber], kWindowBackgroundBlurRadius);

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 nsresult

 nsCocoaWindow::ConfigureChildren(const nsTArray<Configuration>& aConfigurations)

 {

   if (mPopupContentView) {

     mPopupContentView->ConfigureChildren(aConfigurations);

   }

   return NS_OK;

 }

 LayerManager*

 nsCocoaWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,

                                LayersBackend aBackendHint,

                                LayerManagerPersistence aPersistence,

                                bool* aAllowRetaining)

 {

   if (mPopupContentView) {

     return mPopupContentView->GetLayerManager(aShadowManager,

                                               aBackendHint,

                                               aPersistence,

                                               aAllowRetaining);

   }

   return nullptr;

 }

 nsTransparencyMode nsCocoaWindow::GetTransparencyMode()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;

   return (!mWindow || [mWindow isOpaque]) ? eTransparencyOpaque : eTransparencyTransparent;

   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(eTransparencyOpaque);

 }

 // This is called from nsMenuPopupFrame when making a popup transparent.

 // For other window types, nsChildView::SetTransparencyMode is used.

 void nsCocoaWindow::SetTransparencyMode(nsTransparencyMode aMode)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (!mWindow)

     return;

   BOOL isTransparent = aMode == eTransparencyTransparent;

   BOOL currentTransparency = ![mWindow isOpaque];

   if (isTransparent != currentTransparency) {

     [mWindow setOpaque:!isTransparent];

     [mWindow setBackgroundColor:(isTransparent ? [NSColor clearColor] : [NSColor whiteColor])];

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 NS_IMETHODIMP nsCocoaWindow::Enable(bool aState)

 {

   return NS_OK;

 }

 bool nsCocoaWindow::IsEnabled() const

 {

   return true;

 }

 #define kWindowPositionSlop 20

 NS_IMETHODIMP nsCocoaWindow::ConstrainPosition(bool aAllowSlop,

                                                int32_t *aX, int32_t *aY)

 {

   if (!mWindow || ![mWindow screen]) {

     return NS_OK;

   }

   nsIntRect screenBounds;

   int32_t width, height;

   NSRect frame = [mWindow frame];

   // zero size rects confuse the screen manager

   width = std::max<int32_t>(frame.size.width, 1);

   height = std::max<int32_t>(frame.size.height, 1);

   nsCOMPtr<nsIScreenManager> screenMgr = do_GetService("@mozilla.org/gfx/screenmanager;1");

   if (screenMgr) {

     nsCOMPtr<nsIScreen> screen;

     screenMgr->ScreenForRect(*aX, *aY, width, height, getter_AddRefs(screen));

     if (screen) {

       screen->GetRectDisplayPix(&(screenBounds.x), &(screenBounds.y),

                                 &(screenBounds.width), &(screenBounds.height));

     }

   }

   if (aAllowSlop) {

     if (*aX < screenBounds.x - width + kWindowPositionSlop) {

       *aX = screenBounds.x - width + kWindowPositionSlop;

     } else if (*aX >= screenBounds.x + screenBounds.width - kWindowPositionSlop) {

       *aX = screenBounds.x + screenBounds.width - kWindowPositionSlop;

     }

     if (*aY < screenBounds.y - height + kWindowPositionSlop) {

       *aY = screenBounds.y - height + kWindowPositionSlop;

     } else if (*aY >= screenBounds.y + screenBounds.height - kWindowPositionSlop) {

       *aY = screenBounds.y + screenBounds.height - kWindowPositionSlop;

     }

   } else {

     if (*aX < screenBounds.x) {

       *aX = screenBounds.x;

     } else if (*aX >= screenBounds.x + screenBounds.width - width) {

       *aX = screenBounds.x + screenBounds.width - width;

     }

     if (*aY < screenBounds.y) {

       *aY = screenBounds.y;

     } else if (*aY >= screenBounds.y + screenBounds.height - height) {

       *aY = screenBounds.y + screenBounds.height - height;

     }

   }

   return NS_OK;

 }

 void nsCocoaWindow::SetSizeConstraints(const SizeConstraints& aConstraints)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   // Popups can be smaller than (60, 60)

   NSRect rect =

     (mWindowType == eWindowType_popup) ? NSZeroRect : NSMakeRect(0.0, 0.0, 60, 60);

   rect = [mWindow frameRectForContentRect:rect];

   CGFloat scaleFactor = BackingScaleFactor();

   SizeConstraints c = aConstraints;

   c.mMinSize.width =

     std::max(nsCocoaUtils::CocoaPointsToDevPixels(rect.size.width, scaleFactor),

            c.mMinSize.width);

   c.mMinSize.height =

     std::max(nsCocoaUtils::CocoaPointsToDevPixels(rect.size.height, scaleFactor),

            c.mMinSize.height);

   NSSize minSize = {

     nsCocoaUtils::DevPixelsToCocoaPoints(c.mMinSize.width, scaleFactor),

     nsCocoaUtils::DevPixelsToCocoaPoints(c.mMinSize.height, scaleFactor)

   };

   [mWindow setMinSize:minSize];

   NSSize maxSize = {

     c.mMaxSize.width == NS_MAXSIZE ?

       FLT_MAX : nsCocoaUtils::DevPixelsToCocoaPoints(c.mMaxSize.width, scaleFactor),

     c.mMaxSize.height == NS_MAXSIZE ?

       FLT_MAX : nsCocoaUtils::DevPixelsToCocoaPoints(c.mMaxSize.height, scaleFactor)

   };

   [mWindow setMaxSize:maxSize];

   nsBaseWidget::SetSizeConstraints(c);

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 // Coordinates are global display pixels

 NS_IMETHODIMP nsCocoaWindow::Move(double aX, double aY)

 {

   if (!mWindow) {

     return NS_OK;

   }

   // The point we have is in Gecko coordinates (origin top-left). Convert

   // it to Cocoa ones (origin bottom-left).

   NSPoint coord = {

     static_cast<float>(aX),

     static_cast<float>(nsCocoaUtils::FlippedScreenY(NSToIntRound(aY)))

   };

   NSRect frame = [mWindow frame];

   if (frame.origin.x != coord.x ||

       frame.origin.y + frame.size.height != coord.y) {

     [mWindow setFrameTopLeftPoint:coord];

   }

   return NS_OK;

 }

 // Position the window behind the given window

 NS_METHOD nsCocoaWindow::PlaceBehind(nsTopLevelWidgetZPlacement aPlacement,

                                      nsIWidget *aWidget, bool aActivate)

 {

   return NS_OK;

 }

 NS_METHOD nsCocoaWindow::SetSizeMode(int32_t aMode)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow)

     return NS_OK;

   // mSizeMode will be updated in DispatchSizeModeEvent, which will be called

   // from a delegate method that handles the state change during one of the

   // calls below.

   nsSizeMode previousMode = mSizeMode;

   if (aMode == nsSizeMode_Normal) {

     if ([mWindow isMiniaturized])

       [mWindow deminiaturize:nil];

     else if (previousMode == nsSizeMode_Maximized && [mWindow isZoomed])

       [mWindow zoom:nil];

   }

   else if (aMode == nsSizeMode_Minimized) {

     if (![mWindow isMiniaturized])

       [mWindow miniaturize:nil];

   }

   else if (aMode == nsSizeMode_Maximized) {

     if ([mWindow isMiniaturized])

       [mWindow deminiaturize:nil];

     if (![mWindow isZoomed])

       [mWindow zoom:nil];

   }

   else if (aMode == nsSizeMode_Fullscreen) {

     if (!mFullScreen)

       MakeFullScreen(true);

   }

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 // This has to preserve the window's frame bounds.

 // This method requires (as does the Windows impl.) that you call Resize shortly

 // after calling HideWindowChrome. See bug 498835 for fixing this.

 NS_IMETHODIMP nsCocoaWindow::HideWindowChrome(bool aShouldHide)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow || !mWindowMadeHere ||

       (mWindowType != eWindowType_toplevel && mWindowType != eWindowType_dialog))

     return NS_ERROR_FAILURE;

   BOOL isVisible = [mWindow isVisible];

   // Remove child windows.

   NSArray* childWindows = [mWindow childWindows];

   NSEnumerator* enumerator = [childWindows objectEnumerator];

   NSWindow* child = nil;

   while ((child = [enumerator nextObject])) {

     [mWindow removeChildWindow:child];

   }

   // Remove the content view.

   NSView* contentView = [mWindow contentView];

   [contentView retain];

   [contentView removeFromSuperviewWithoutNeedingDisplay];

   // Save state (like window title).

   NSMutableDictionary* state = [mWindow exportState];

   // Recreate the window with the right border style.

   NSRect frameRect = [mWindow frame];

   DestroyNativeWindow();

   nsresult rv = CreateNativeWindow(frameRect, aShouldHide ? eBorderStyle_none : mBorderStyle, true);

   NS_ENSURE_SUCCESS(rv, rv);

   // Re-import state.

   [mWindow importState:state];

   // Reparent the content view.

   [mWindow setContentView:contentView];

   [contentView release];

   // Reparent child windows.

   enumerator = [childWindows objectEnumerator];

   while ((child = [enumerator nextObject])) {

     [mWindow addChildWindow:child ordered:NSWindowAbove];

   }

   // Show the new window.

   if (isVisible) {

     rv = Show(true);

     NS_ENSURE_SUCCESS(rv, rv);

   }

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 void nsCocoaWindow::EnteredFullScreen(bool aFullScreen)

 {

   mInFullScreenTransition = false;

   mFullScreen = aFullScreen;

   DispatchSizeModeEvent();

 }

 NS_METHOD nsCocoaWindow::MakeFullScreen(bool aFullScreen)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow) {

     return NS_OK;

   }

   // We will call into MakeFullScreen redundantly when entering/exiting

   // fullscreen mode via OS X controls. When that happens we should just handle

   // it gracefully - no need to ASSERT.

   if (mFullScreen == aFullScreen) {

     return NS_OK;

   }

   // If we're using native fullscreen mode and our native window is invisible,

   // our attempt to go into fullscreen mode will fail with an assertion in

   // system code, without [WindowDelegate windowDidFailToEnterFullScreen:]

   // ever getting called.  To pre-empt this we bail here.  See bug 752294.

   if (mUsesNativeFullScreen && aFullScreen && ![mWindow isVisible]) {

     EnteredFullScreen(false);

     return NS_OK;

   }

   mInFullScreenTransition = true;

   if (mUsesNativeFullScreen) {

     // Calling toggleFullScreen will result in windowDid(FailTo)?(Enter|Exit)FullScreen

     // to be called from the OS. We will call EnteredFullScreen from those methods,

     // where mFullScreen will be set and a sizemode event will be dispatched.

     [mWindow toggleFullScreen:nil];

   } else {

     NSDisableScreenUpdates();

     // The order here matters. When we exit full screen mode, we need to show the

     // Dock first, otherwise the newly-created window won't have its minimize

     // button enabled. See bug 526282.

     nsCocoaUtils::HideOSChromeOnScreen(aFullScreen, [mWindow screen]);

     nsresult rv = nsBaseWidget::MakeFullScreen(aFullScreen);

     NSEnableScreenUpdates();

     NS_ENSURE_SUCCESS(rv, rv);

     EnteredFullScreen(aFullScreen);

   }

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 // Coordinates are global display pixels

 nsresult nsCocoaWindow::DoResize(double aX, double aY,

                                  double aWidth, double aHeight,

                                  bool aRepaint,

                                  bool aConstrainToCurrentScreen)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow || mInResize) {

     return NS_OK;

   }

   AutoRestore<bool> reentrantResizeGuard(mInResize);

   mInResize = true;

   // ConstrainSize operates in device pixels, so we need to convert using

   // the backing scale factor here

   CGFloat scale = BackingScaleFactor();

   int32_t width = NSToIntRound(aWidth * scale);

   int32_t height = NSToIntRound(aHeight * scale);

   ConstrainSize(&width, &height);

   nsIntRect newBounds(NSToIntRound(aX), NSToIntRound(aY),

                       NSToIntRound(width / scale),

                       NSToIntRound(height / scale));

   // constrain to the screen that contains the largest area of the new rect

   FitRectToVisibleAreaForScreen(newBounds,

                                 aConstrainToCurrentScreen ?

                                   [mWindow screen] : nullptr,

                                 mUsesNativeFullScreen);

   // convert requested bounds into Cocoa coordinate system

   NSRect newFrame = nsCocoaUtils::GeckoRectToCocoaRect(newBounds);

   NSRect frame = [mWindow frame];

   BOOL isMoving = newFrame.origin.x != frame.origin.x ||

                   newFrame.origin.y != frame.origin.y;

   BOOL isResizing = newFrame.size.width != frame.size.width ||

                     newFrame.size.height != frame.size.height;

   if (!isMoving && !isResizing) {

     return NS_OK;

   }

   // We ignore aRepaint -- we have to call display:YES, otherwise the

   // title bar doesn't immediately get repainted and is displayed in

   // the wrong place, leading to a visual jump.

   [mWindow setFrame:newFrame display:YES];

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 // Coordinates are global display pixels

 NS_IMETHODIMP nsCocoaWindow::Resize(double aX, double aY,

                                     double aWidth, double aHeight,

                                     bool aRepaint)

 {

   return DoResize(aX, aY, aWidth, aHeight, aRepaint, false);

 }

 // Coordinates are global display pixels

 NS_IMETHODIMP nsCocoaWindow::Resize(double aWidth, double aHeight, bool aRepaint)

 {

   double invScale = 1.0 / GetDefaultScale().scale;

   return DoResize(mBounds.x * invScale, mBounds.y * invScale,

                   aWidth, aHeight, aRepaint, true);

 }

 NS_IMETHODIMP nsCocoaWindow::GetClientBounds(nsIntRect &aRect)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   CGFloat scaleFactor = BackingScaleFactor();

   if (!mWindow) {

     aRect = nsCocoaUtils::CocoaRectToGeckoRectDevPix(NSZeroRect, scaleFactor);

     return NS_OK;

   }

   NSRect r;

   if ([mWindow isKindOfClass:[ToolbarWindow class]] &&

       [(ToolbarWindow*)mWindow drawsContentsIntoWindowFrame]) {

     r = [mWindow frame];

   } else {

     r = [mWindow contentRectForFrameRect:[mWindow frame]];

   }

   aRect = nsCocoaUtils::CocoaRectToGeckoRectDevPix(r, scaleFactor);

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 void

 nsCocoaWindow::UpdateBounds()

 {

   NSRect frame = NSZeroRect;

   if (mWindow) {

     frame = [mWindow frame];

   }

   mBounds = nsCocoaUtils::CocoaRectToGeckoRectDevPix(frame, BackingScaleFactor());

 }

 NS_IMETHODIMP nsCocoaWindow::GetScreenBounds(nsIntRect &aRect)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

 #ifdef DEBUG

   nsIntRect r = nsCocoaUtils::CocoaRectToGeckoRectDevPix([mWindow frame], BackingScaleFactor());

   NS_ASSERTION(mWindow && mBounds == r, "mBounds out of sync!");

 #endif

   aRect = mBounds;

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 double

 nsCocoaWindow::GetDefaultScaleInternal()

 {

   return BackingScaleFactor();

 }

 static CGFloat

 GetBackingScaleFactor(NSWindow* aWindow)

 {

   NSRect frame = [aWindow frame];

   if (frame.size.width > 0 && frame.size.height > 0) {

     return nsCocoaUtils::GetBackingScaleFactor(aWindow);

   }

   // For windows with zero width or height, the backingScaleFactor method

   // is broken - it will always return 2 on a retina macbook, even when

   // the window position implies it's on a non-hidpi external display

   // (to the extent that a zero-area window can be said to be "on" a

   // display at all!)

   // And to make matters worse, Cocoa even fires a

   // windowDidChangeBackingProperties notification with the

   // NSBackingPropertyOldScaleFactorKey key when a window on an

   // external display is resized to/from zero height, even though it hasn't

   // really changed screens.

   // This causes us to handle popup window sizing incorrectly when the

   // popup is resized to zero height (bug 820327) - nsXULPopupManager

   // becomes (incorrectly) convinced the popup has been explicitly forced

   // to a non-default size and needs to have size attributes attached.

   // Workaround: instead of asking the window, we'll find the screen it is on

   // and ask that for *its* backing scale factor.

   // (See bug 853252 and additional comments in windowDidChangeScreen: below

   // for further complications this causes.)

   // First, expand the rect so that it actually has a measurable area,

   // for FindTargetScreenForRect to use.

   if (frame.size.width == 0) {

     frame.size.width = 1;

   }

   if (frame.size.height == 0) {

     frame.size.height = 1;

   }

   // Then identify the screen it belongs to, and return its scale factor.

   NSScreen *screen =

     FindTargetScreenForRect(nsCocoaUtils::CocoaRectToGeckoRect(frame));

   return nsCocoaUtils::GetBackingScaleFactor(screen);

 }

 CGFloat

 nsCocoaWindow::BackingScaleFactor()

 {

   if (mBackingScaleFactor > 0.0) {

     return mBackingScaleFactor;

   }

   if (!mWindow) {

     return 1.0;

   }

   mBackingScaleFactor = GetBackingScaleFactor(mWindow);

   return mBackingScaleFactor;

 }

 void

 nsCocoaWindow::BackingScaleFactorChanged()

 {

   CGFloat newScale = GetBackingScaleFactor(mWindow);

   // ignore notification if it hasn't really changed (or maybe we have

   // disabled HiDPI mode via prefs)

   if (mBackingScaleFactor == newScale) {

     return;

   }

   if (mBackingScaleFactor > 0.0) {

     // convert size constraints to the new device pixel coordinate space

     double scaleFactor = newScale / mBackingScaleFactor;

     mSizeConstraints.mMinSize.width =

       NSToIntRound(mSizeConstraints.mMinSize.width * scaleFactor);

     mSizeConstraints.mMinSize.height =

       NSToIntRound(mSizeConstraints.mMinSize.height * scaleFactor);

     if (mSizeConstraints.mMaxSize.width < NS_MAXSIZE) {

       mSizeConstraints.mMaxSize.width =

         std::min(NS_MAXSIZE,

                NSToIntRound(mSizeConstraints.mMaxSize.width * scaleFactor));

     }

     if (mSizeConstraints.mMaxSize.height < NS_MAXSIZE) {

       mSizeConstraints.mMaxSize.height =

         std::min(NS_MAXSIZE,

                NSToIntRound(mSizeConstraints.mMaxSize.height * scaleFactor));

     }

   }

   mBackingScaleFactor = newScale;

   if (!mWidgetListener || mWidgetListener->GetXULWindow()) {

     return;

   }

   nsIPresShell* presShell = mWidgetListener->GetPresShell();

   if (presShell) {

     presShell->BackingScaleFactorChanged();

   }

 }

 int32_t

 nsCocoaWindow::RoundsWidgetCoordinatesTo()

 {

   if (BackingScaleFactor() == 2.0) {

     return 2;

   }

   return 1;

 }

 NS_IMETHODIMP nsCocoaWindow::SetCursor(nsCursor aCursor)

 {

   if (mPopupContentView)

     return mPopupContentView->SetCursor(aCursor);

   return NS_OK;

 }

 NS_IMETHODIMP nsCocoaWindow::SetCursor(imgIContainer* aCursor,

                                        uint32_t aHotspotX, uint32_t aHotspotY)

 {

   if (mPopupContentView)

     return mPopupContentView->SetCursor(aCursor, aHotspotX, aHotspotY);

   return NS_OK;

 }

 NS_IMETHODIMP nsCocoaWindow::SetTitle(const nsAString& aTitle)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow)

     return NS_OK;

   const nsString& strTitle = PromiseFlatString(aTitle);

   NSString* title = [NSString stringWithCharacters:reinterpret_cast<const unichar*>(strTitle.get())

                                             length:strTitle.Length()];

   if ([mWindow drawsContentsIntoWindowFrame] && ![mWindow wantsTitleDrawn]) {

     // Don't cause invalidations.

     [mWindow disableSetNeedsDisplay];

     [mWindow setTitle:title];

     [mWindow enableSetNeedsDisplay];

   } else {

     [mWindow setTitle:title];

   }

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 NS_IMETHODIMP nsCocoaWindow::Invalidate(const nsIntRect & aRect)

 {

   if (mPopupContentView) {

     return mPopupContentView->Invalidate(aRect);

   }

   return NS_OK;

 }

 // Pass notification of some drag event to Gecko

 //

 // The drag manager has let us know that something related to a drag has

 // occurred in this window. It could be any number of things, ranging from 

 // a drop, to a drag enter/leave, or a drag over event. The actual event

 // is passed in |aMessage| and is passed along to our event hanlder so Gecko

 // knows about it.

 bool nsCocoaWindow::DragEvent(unsigned int aMessage, Point aMouseGlobal, UInt16 aKeyModifiers)

 {

   return false;

 }

 NS_IMETHODIMP nsCocoaWindow::SendSetZLevelEvent()

 {

   nsWindowZ placement = nsWindowZTop;

   nsIWidget* actualBelow;

   if (mWidgetListener)

     mWidgetListener->ZLevelChanged(true, &placement, nullptr, &actualBelow);

   return NS_OK;

 }

 NS_IMETHODIMP nsCocoaWindow::GetChildSheet(bool aShown, nsCocoaWindow** _retval)

 {

   nsIWidget* child = GetFirstChild();

   while (child) {

     if (child->WindowType() == eWindowType_sheet) {

       // if it's a sheet, it must be an nsCocoaWindow

       nsCocoaWindow* cocoaWindow = static_cast<nsCocoaWindow*>(child);

       if (cocoaWindow->mWindow &&

           ((aShown && [cocoaWindow->mWindow isVisible]) ||

           (!aShown && cocoaWindow->mSheetNeedsShow))) {

         *_retval = cocoaWindow;

         return NS_OK;

       }

     }

     child = child->GetNextSibling();

   }

   *_retval = nullptr;

   return NS_OK;

 }

 NS_IMETHODIMP nsCocoaWindow::GetRealParent(nsIWidget** parent)

 {

   *parent = mParent;

   return NS_OK;

 }

 NS_IMETHODIMP nsCocoaWindow::GetIsSheet(bool* isSheet)

 {

   mWindowType == eWindowType_sheet ? *isSheet = true : *isSheet = false;

   return NS_OK;

 }

 NS_IMETHODIMP nsCocoaWindow::GetSheetWindowParent(NSWindow** sheetWindowParent)

 {

   *sheetWindowParent = mSheetWindowParent;

   return NS_OK;

 }

 // Invokes callback and ProcessEvent methods on Event Listener object

 NS_IMETHODIMP 

 nsCocoaWindow::DispatchEvent(WidgetGUIEvent* event, nsEventStatus& aStatus)

 {

   aStatus = nsEventStatus_eIgnore;

   nsIWidget* aWidget = event->widget;

   NS_IF_ADDREF(aWidget);

   if (mWidgetListener)

     aStatus = mWidgetListener->HandleEvent(event, mUseAttachedEvents);

   NS_IF_RELEASE(aWidget);

   return NS_OK;

 }

 // aFullScreen should be the window's mFullScreen. We don't have access to that

 // from here, so we need to pass it in. mFullScreen should be the canonical

 // indicator that a window is currently full screen and it makes sense to keep

 // all sizemode logic here.

 static nsSizeMode

 GetWindowSizeMode(NSWindow* aWindow, bool aFullScreen) {

   if (aFullScreen)

     return nsSizeMode_Fullscreen;

   if ([aWindow isMiniaturized])

     return nsSizeMode_Minimized;

   if (([aWindow styleMask] & NSResizableWindowMask) && [aWindow isZoomed])

     return nsSizeMode_Maximized;

   return nsSizeMode_Normal;

 }

 void

 nsCocoaWindow::ReportMoveEvent()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   // Prevent recursion, which can become infinite (see bug 708278).  This

   // can happen when the call to [NSWindow setFrameTopLeftPoint:] in

   // nsCocoaWindow::Move() triggers an immediate NSWindowDidMove notification

   // (and a call to [WindowDelegate windowDidMove:]).

   if (mInReportMoveEvent) {

     return;

   }

   mInReportMoveEvent = true;

   UpdateBounds();

   // Dispatch the move event to Gecko

   NotifyWindowMoved(mBounds.x, mBounds.y);

   mInReportMoveEvent = false;

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void

 nsCocoaWindow::DispatchSizeModeEvent()

 {

   if (!mWindow) {

     return;

   }

   nsSizeMode newMode = GetWindowSizeMode(mWindow, mFullScreen);

   // Don't dispatch a sizemode event if:

   // 1. the window is transitioning to fullscreen

   // 2. the new sizemode is the same as the current sizemode

   if (mInFullScreenTransition || mSizeMode == newMode) {

     return;

   }

   mSizeMode = newMode;

   if (mWidgetListener) {

     mWidgetListener->SizeModeChanged(newMode);

   }

 }

 void

 nsCocoaWindow::ReportSizeEvent()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   UpdateBounds();

   if (mWidgetListener) {

     nsIntRect innerBounds;

     GetClientBounds(innerBounds);

     mWidgetListener->WindowResized(this, innerBounds.width, innerBounds.height);

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void nsCocoaWindow::SetMenuBar(nsMenuBarX *aMenuBar)

 {

   if (mMenuBar)

     mMenuBar->SetParent(nullptr);

   if (!mWindow) {

     mMenuBar = nullptr;

     return;

   }

   mMenuBar = aMenuBar;

   // Only paint for active windows, or paint the hidden window menu bar if no

   // other menu bar has been painted yet so that some reasonable menu bar is

   // displayed when the app starts up.

   id windowDelegate = [mWindow delegate];

   if (mMenuBar &&

       ((!gSomeMenuBarPainted && nsMenuUtilsX::GetHiddenWindowMenuBar() == mMenuBar) ||

        (windowDelegate && [windowDelegate toplevelActiveState])))

     mMenuBar->Paint();

 }

 NS_IMETHODIMP nsCocoaWindow::SetFocus(bool aState)

 {

   if (!mWindow)

     return NS_OK;

   if (mPopupContentView) {

     mPopupContentView->SetFocus(aState);

   }

   else if (aState && ([mWindow isVisible] || [mWindow isMiniaturized])) {

     [mWindow makeKeyAndOrderFront:nil];

     SendSetZLevelEvent();

   }

   return NS_OK;

 }

 nsIntPoint nsCocoaWindow::WidgetToScreenOffset()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;

   NSRect rect = NSZeroRect;

   nsIntRect r;

   if (mWindow) {

     rect = [mWindow contentRectForFrameRect:[mWindow frame]];

   }

   r = nsCocoaUtils::CocoaRectToGeckoRectDevPix(rect, BackingScaleFactor());

   return r.TopLeft();

   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(nsIntPoint(0,0));

 }

 nsIntPoint nsCocoaWindow::GetClientOffset()

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;

   nsIntRect clientRect;

   GetClientBounds(clientRect);

   return clientRect.TopLeft() - mBounds.TopLeft();

   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(nsIntPoint(0, 0));

 }

 nsIntSize nsCocoaWindow::ClientToWindowSize(const nsIntSize& aClientSize)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;

   if (!mWindow)

     return nsIntSize(0, 0);

   CGFloat backingScale = BackingScaleFactor();

   nsIntRect r(0, 0, aClientSize.width, aClientSize.height);

   NSRect rect = nsCocoaUtils::DevPixelsToCocoaPoints(r, backingScale);

   NSRect inflatedRect = [mWindow frameRectForContentRect:rect];

   return nsCocoaUtils::CocoaRectToGeckoRectDevPix(inflatedRect, backingScale).Size();

   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(nsIntSize(0,0));

 }

 nsMenuBarX* nsCocoaWindow::GetMenuBar()

 {

   return mMenuBar;

 }

 NS_IMETHODIMP nsCocoaWindow::CaptureRollupEvents(nsIRollupListener* aListener, bool aDoCapture)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   gRollupListener = nullptr;

   if (aDoCapture) {

     if (![NSApp isActive]) {

       // We need to capture mouse event if we aren't

       // the active application. We only set this up when needed

       // because they cause spurious mouse event after crash

       // and gdb sessions. See bug 699538.

       nsToolkit::GetToolkit()->RegisterForAllProcessMouseEvents();

     }

     gRollupListener = aListener;

     // Sometimes more than one popup window can be visible at the same time

     // (e.g. nested non-native context menus, or the test case (attachment

     // 276885) for bmo bug 392389, which displays a non-native combo-box in a

     // non-native popup window).  In these cases the "active" popup window should

     // be the topmost -- the (nested) context menu the mouse is currently over,

     // or the combo-box's drop-down list (when it's displayed).  But (among

     // windows that have the same "level") OS X makes topmost the window that

     // last received a mouse-down event, which may be incorrect (in the combo-

     // box case, it makes topmost the window containing the combo-box).  So

     // here we fiddle with a non-native popup window's level to make sure the

     // "active" one is always above any other non-native popup windows that

     // may be visible.

     if (mWindow && (mWindowType == eWindowType_popup))

       SetPopupWindowLevel();

   } else {

     nsToolkit::GetToolkit()->UnregisterAllProcessMouseEventHandlers();

     // XXXndeakin this doesn't make sense.

     // Why is the new window assumed to be a modal panel?

     if (mWindow && (mWindowType == eWindowType_popup))

       [mWindow setLevel:NSModalPanelWindowLevel];

   }

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 NS_IMETHODIMP nsCocoaWindow::GetAttention(int32_t aCycleCount)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   [NSApp requestUserAttention:NSInformationalRequest];

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 bool

 nsCocoaWindow::HasPendingInputEvent()

 {

   return nsChildView::DoHasPendingInputEvent();

 }

 NS_IMETHODIMP nsCocoaWindow::SetWindowShadowStyle(int32_t aStyle)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow)

     return NS_OK;

   mShadowStyle = aStyle;

   [mWindow setHasShadow:(aStyle != NS_STYLE_WINDOW_SHADOW_NONE)];

   AdjustWindowShadow();

   SetWindowBackgroundBlur();

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 void nsCocoaWindow::SetShowsToolbarButton(bool aShow)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (mWindow)

     [mWindow setShowsToolbarButton:aShow];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void nsCocoaWindow::SetShowsFullScreenButton(bool aShow)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (!mWindow || ![mWindow respondsToSelector:@selector(toggleFullScreen:)] ||

       mUsesNativeFullScreen == aShow) {

     return;

   }

   // If the window is currently in fullscreen mode, then we're going to

   // transition out first, then set the collection behavior & toggle

   // mUsesNativeFullScreen, then transtion back into fullscreen mode. This

   // prevents us from getting into a conflicting state with MakeFullScreen

   // where mUsesNativeFullScreen would lead us down the wrong path.

   bool wasFullScreen = mFullScreen;

   if (wasFullScreen) {

     MakeFullScreen(false);

   }

   NSWindowCollectionBehavior newBehavior = [mWindow collectionBehavior];

   if (aShow) {

     newBehavior |= NSWindowCollectionBehaviorFullScreenPrimary;

   } else {

     newBehavior &= ~NSWindowCollectionBehaviorFullScreenPrimary;

   }

   [mWindow setCollectionBehavior:newBehavior];

   mUsesNativeFullScreen = aShow;

   if (wasFullScreen) {

     MakeFullScreen(true);

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 void nsCocoaWindow::SetWindowAnimationType(nsIWidget::WindowAnimationType aType)

 {

   mAnimationType = aType;

 }

 void

 nsCocoaWindow::SetDrawsTitle(bool aDrawTitle)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   [mWindow setWantsTitleDrawn:aDrawTitle];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 NS_IMETHODIMP nsCocoaWindow::SetNonClientMargins(nsIntMargin &margins)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   SetDrawsInTitlebar(margins.top == 0);

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 NS_IMETHODIMP nsCocoaWindow::SetWindowTitlebarColor(nscolor aColor, bool aActive)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (!mWindow)

     return NS_OK;

   // If they pass a color with a complete transparent alpha component, use the

   // native titlebar appearance.

   if (NS_GET_A(aColor) == 0) {

     [mWindow setTitlebarColor:nil forActiveWindow:(BOOL)aActive]; 

   } else {

     // Transform from sRGBA to monitor RGBA. This seems like it would make trying

     // to match the system appearance lame, so probably we just shouldn't color 

     // correct chrome.

     if (gfxPlatform::GetCMSMode() == eCMSMode_All) {

       qcms_transform *transform = gfxPlatform::GetCMSRGBATransform();

       if (transform) {

         uint8_t color[3];

         color[0] = NS_GET_R(aColor);

         color[1] = NS_GET_G(aColor);

         color[2] = NS_GET_B(aColor);

         qcms_transform_data(transform, color, color, 1);

         aColor = NS_RGB(color[0], color[1], color[2]);

       }

     }

     [mWindow setTitlebarColor:[NSColor colorWithDeviceRed:NS_GET_R(aColor)/255.0

                                                     green:NS_GET_G(aColor)/255.0

                                                      blue:NS_GET_B(aColor)/255.0

                                                     alpha:NS_GET_A(aColor)/255.0]

               forActiveWindow:(BOOL)aActive];

   }

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 void nsCocoaWindow::SetDrawsInTitlebar(bool aState)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (mWindow)

     [mWindow setDrawsContentsIntoWindowFrame:aState];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 NS_IMETHODIMP nsCocoaWindow::SynthesizeNativeMouseEvent(nsIntPoint aPoint,

                                                         uint32_t aNativeMessage,

                                                         uint32_t aModifierFlags)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;

   if (mPopupContentView)

     return mPopupContentView->SynthesizeNativeMouseEvent(aPoint, aNativeMessage,

                                                          aModifierFlags);

   return NS_OK;

   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

 }

 gfxASurface* nsCocoaWindow::GetThebesSurface()

 {

   if (mPopupContentView)

     return mPopupContentView->GetThebesSurface();

   return nullptr;

 }

 void nsCocoaWindow::SetPopupWindowLevel()

 {

   if (!mWindow)

     return;

   // Floating popups are at the floating level and hide when the window is

   // deactivated.

   if (mPopupLevel == ePopupLevelFloating) {

     [mWindow setLevel:NSFloatingWindowLevel];

     [mWindow setHidesOnDeactivate:YES];

   }

   else {

     // Otherwise, this is a top-level or parent popup. Parent popups always

     // appear just above their parent and essentially ignore the level.

     [mWindow setLevel:NSPopUpMenuWindowLevel];

     [mWindow setHidesOnDeactivate:NO];

   }

 }

 NS_IMETHODIMP

 nsCocoaWindow::NotifyIME(const IMENotification& aIMENotification)

 {

   switch (aIMENotification.mMessage) {

     case NOTIFY_IME_OF_FOCUS:

       if (mInputContext.IsPasswordEditor()) {

         TextInputHandler::EnableSecureEventInput();

       }

       return NS_OK;

     case NOTIFY_IME_OF_BLUR:

       // When we're going to be deactive, we must disable the secure event input

       // mode, see the Carbon Event Manager Reference.

       TextInputHandler::EnsureSecureEventInputDisabled();

       return NS_OK;

     default:

       return NS_ERROR_NOT_IMPLEMENTED;

   }

 }

 NS_IMETHODIMP_(void)

 nsCocoaWindow::SetInputContext(const InputContext& aContext,

                                const InputContextAction& aAction)

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   if (mWindow &&

       [mWindow firstResponder] == mWindow &&

       [mWindow isKeyWindow] &&

       [[NSApplication sharedApplication] isActive]) {

     if (aContext.IsPasswordEditor()) {

       TextInputHandler::EnableSecureEventInput();

     } else {

       TextInputHandler::EnsureSecureEventInputDisabled();

     }

   }

   mInputContext = aContext;

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 NS_IMETHODIMP_(bool)

 nsCocoaWindow::ExecuteNativeKeyBinding(NativeKeyBindingsType aType,

                                        const WidgetKeyboardEvent& aEvent,

                                        DoCommandCallback aCallback,

                                        void* aCallbackData)

 {

   NativeKeyBindings* keyBindings = NativeKeyBindings::GetInstance(aType);

   return keyBindings->Execute(aEvent, aCallback, aCallbackData);

 }

 @implementation WindowDelegate

 // We try to find a gecko menu bar to paint. If one does not exist, just paint

 // the application menu by itself so that a window doesn't have some other

 // window's menu bar.

 + (void)paintMenubarForWindow:(NSWindow*)aWindow

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   // make sure we only act on windows that have this kind of

   // object as a delegate

   id windowDelegate = [aWindow delegate];

   if ([windowDelegate class] != [self class])

     return;

   nsCocoaWindow* geckoWidget = [windowDelegate geckoWidget];

   NS_ASSERTION(geckoWidget, "Window delegate not returning a gecko widget!");

   nsMenuBarX* geckoMenuBar = geckoWidget->GetMenuBar();

   if (geckoMenuBar) {

     geckoMenuBar->Paint();

   }

   else {

     // sometimes we don't have a native application menu early in launching

     if (!sApplicationMenu)

       return;

     NSMenu* mainMenu = [NSApp mainMenu];

     NS_ASSERTION([mainMenu numberOfItems] > 0, "Main menu does not have any items, something is terribly wrong!");

     // Create a new menu bar.

     // We create a GeckoNSMenu because all menu bar NSMenu objects should use that subclass for

     // key handling reasons.

     GeckoNSMenu* newMenuBar = [[GeckoNSMenu alloc] initWithTitle:@"MainMenuBar"];

     // move the application menu from the existing menu bar to the new one

     NSMenuItem* firstMenuItem = [[mainMenu itemAtIndex:0] retain];

     [mainMenu removeItemAtIndex:0];

     [newMenuBar insertItem:firstMenuItem atIndex:0];

     [firstMenuItem release];

     // set our new menu bar as the main menu

     [NSApp setMainMenu:newMenuBar];

     [newMenuBar release];

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 - (id)initWithGeckoWindow:(nsCocoaWindow*)geckoWind

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;

   [super init];

   mGeckoWindow = geckoWind;

   mToplevelActiveState = false;

   mHasEverBeenZoomed = false;

   return self;

   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;

 }

 - (NSSize)windowWillResize:(NSWindow *)sender toSize:(NSSize)proposedFrameSize

 {

   RollUpPopups();

   return proposedFrameSize;

 }

 - (void)windowDidResize:(NSNotification *)aNotification

 {

   BaseWindow* window = [aNotification object];

   [window updateTrackingArea];

   if (!mGeckoWindow)

     return;

   // Resizing might have changed our zoom state.

   mGeckoWindow->DispatchSizeModeEvent();

   mGeckoWindow->ReportSizeEvent();

 }

 - (void)windowDidChangeScreen:(NSNotification *)aNotification

 {

   if (!mGeckoWindow)

     return;

   // Because of Cocoa's peculiar treatment of zero-size windows (see comments

   // at GetBackingScaleFactor() above), we sometimes have a situation where

   // our concept of backing scale (based on the screen where the zero-sized

   // window is positioned) differs from Cocoa's idea (always based on the

   // Retina screen, AFAICT, even when an external non-Retina screen is the

   // primary display).

   //

   // As a result, if the window was created with zero size on an external

   // display, but then made visible on the (secondary) Retina screen, we

   // will *not* get a windowDidChangeBackingProperties notification for it.

   // This leads to an incorrect GetDefaultScale(), and widget coordinate

   // confusion, as per bug 853252.

   //

   // To work around this, we check for a backing scale mismatch when we

   // receive a windowDidChangeScreen notification, as we will receive this

   // even if Cocoa was already treating the zero-size window as having

   // Retina backing scale.

   NSWindow *window = (NSWindow *)[aNotification object];

   if ([window respondsToSelector:@selector(backingScaleFactor)]) {

     if (GetBackingScaleFactor(window) != mGeckoWindow->BackingScaleFactor()) {

       mGeckoWindow->BackingScaleFactorChanged();

     }

   }

   mGeckoWindow->ReportMoveEvent();

 }

 // Lion's full screen mode will bypass our internal fullscreen tracking, so

 // we need to catch it when we transition and call our own methods, which in

 // turn will fire "fullscreen" events.

 - (void)windowDidEnterFullScreen:(NSNotification *)notification

 {

   if (!mGeckoWindow) {

     return;

   }

   mGeckoWindow->EnteredFullScreen(true);

 }

 - (void)windowDidExitFullScreen:(NSNotification *)notification

 {

   if (!mGeckoWindow) {

     return;

   }

   mGeckoWindow->EnteredFullScreen(false);

 }

 - (void)windowDidFailToEnterFullScreen:(NSWindow *)window

 {

   if (!mGeckoWindow) {

     return;

   }

   mGeckoWindow->EnteredFullScreen(false);

 }

 - (void)windowDidFailToExitFullScreen:(NSWindow *)window

 {

   if (!mGeckoWindow) {

     return;

   }

   mGeckoWindow->EnteredFullScreen(true);

 }

 - (void)windowDidBecomeMain:(NSNotification *)aNotification

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   RollUpPopups();

   ChildViewMouseTracker::ReEvaluateMouseEnterState();

   // [NSApp _isRunningAppModal] will return true if we're running an OS dialog

   // app modally. If one of those is up then we want it to retain its menu bar.

   if ([NSApp _isRunningAppModal])

     return;

   NSWindow* window = [aNotification object];

   if (window)

     [WindowDelegate paintMenubarForWindow:window];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 - (void)windowDidResignMain:(NSNotification *)aNotification

 {

   RollUpPopups();

   ChildViewMouseTracker::ReEvaluateMouseEnterState();

   // [NSApp _isRunningAppModal] will return true if we're running an OS dialog

   // app modally. If one of those is up then we want it to retain its menu bar.

   if ([NSApp _isRunningAppModal])

     return;

   nsRefPtr<nsMenuBarX> hiddenWindowMenuBar = nsMenuUtilsX::GetHiddenWindowMenuBar();

   if (hiddenWindowMenuBar) {

     // printf("painting hidden window menu bar due to window losing main status\n");

     hiddenWindowMenuBar->Paint();

   }

 }

 - (void)windowDidBecomeKey:(NSNotification *)aNotification

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   RollUpPopups();

   ChildViewMouseTracker::ReEvaluateMouseEnterState();

   NSWindow* window = [aNotification object];

   if ([window isSheet])

     [WindowDelegate paintMenubarForWindow:window];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 - (void)windowDidResignKey:(NSNotification *)aNotification

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   RollUpPopups();

   ChildViewMouseTracker::ReEvaluateMouseEnterState();

   // If a sheet just resigned key then we should paint the menu bar

   // for whatever window is now main.

   NSWindow* window = [aNotification object];

   if ([window isSheet])

     [WindowDelegate paintMenubarForWindow:[NSApp mainWindow]];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 - (void)windowWillMove:(NSNotification *)aNotification

 {

   RollUpPopups();

 }

 - (void)windowDidMove:(NSNotification *)aNotification

 {

   if (mGeckoWindow)

     mGeckoWindow->ReportMoveEvent();

 }

 - (BOOL)windowShouldClose:(id)sender

 {

   nsIWidgetListener* listener = mGeckoWindow ? mGeckoWindow->GetWidgetListener() : nullptr;

   if (listener)

     listener->RequestWindowClose(mGeckoWindow);

   return NO; // gecko will do it

 }

 - (void)windowWillClose:(NSNotification *)aNotification

 {

   RollUpPopups();

 }

 - (void)windowWillMiniaturize:(NSNotification *)aNotification

 {

   RollUpPopups();

 }

 - (void)windowDidMiniaturize:(NSNotification *)aNotification

 {

   if (mGeckoWindow)

     mGeckoWindow->DispatchSizeModeEvent();

 }

 - (void)windowDidDeminiaturize:(NSNotification *)aNotification

 {

   if (mGeckoWindow)

     mGeckoWindow->DispatchSizeModeEvent();

 }

 - (BOOL)windowShouldZoom:(NSWindow *)window toFrame:(NSRect)proposedFrame

 {

   if (!mHasEverBeenZoomed && [window isZoomed])

     return NO; // See bug 429954.

   mHasEverBeenZoomed = YES;

   return YES;

 }

 - (void)didEndSheet:(NSWindow*)sheet returnCode:(int)returnCode contextInfo:(void*)contextInfo

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   // Note: 'contextInfo' (if it is set) is the window that is the parent of

   // the sheet.  The value of contextInfo is determined in

   // nsCocoaWindow::Show().  If it's set, 'contextInfo' is always the top-

   // level window, not another sheet itself.  But 'contextInfo' is nil if

   // our parent window is also a sheet -- in that case we shouldn't send

   // the top-level window any activate events (because it's our parent

   // window that needs to get these events, not the top-level window).

   [TopLevelWindowData deactivateInWindow:sheet];

   [sheet orderOut:self];

   if (contextInfo)

     [TopLevelWindowData activateInWindow:(NSWindow*)contextInfo];

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 - (void)windowDidChangeBackingProperties:(NSNotification *)aNotification

 {

   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;

   NSWindow *window = (NSWindow *)[aNotification object];

   if ([window respondsToSelector:@selector(backingScaleFactor)]) {

     CGFloat oldFactor =

       [[[aNotification userInfo]

          objectForKey:@"NSBackingPropertyOldScaleFactorKey"] doubleValue];

     if ([window backingScaleFactor] != oldFactor) {

       mGeckoWindow->BackingScaleFactorChanged();

     }

   }

   NS_OBJC_END_TRY_ABORT_BLOCK;

 }

 - (nsCocoaWindow*)geckoWidget

 {

   return mGeckoWindow;

 }

 - (bool)toplevelActiveState

 {

   return mToplevelActiveState;

 }

 - (void)sendToplevelActivateEvents

 {

   if (!mToplevelActiveState && mGeckoWindow) {

     nsIWidgetListener* listener = mGeckoWindow->GetWidgetListener();

     if (listener)

       listener->WindowActivated();

     mToplevelActiveState = true;

   }

 }

 - (void)sendToplevelDeactivateEvents

 {

   if (mToplevelActiveState && mGeckoWindow) {

     nsIWidgetListener* listener = mGeckoWindow->GetWidgetListener();

     if (listener)

       listener->WindowDeactivated();

     mToplevelActiveState = false;

   }

 }

 @end

 static float

 GetDPI(NSWindow* aWindow)

 {

   NSScreen* screen = [aWindow screen];

   if (!screen)

     return 96.0f;

   CGDirectDisplayID displayID =

     [[[screen deviceDescription] objectForKey:@"NSScreenNumber"] intValue];

   CGFloat heightMM = ::CGDisplayScreenSize(displayID).height;

   size_t heightPx = ::CGDisplayPixelsHigh(displayID);

   CGFloat scaleFactor = [aWindow userSpaceScaleFactor];

   if (scaleFactor < 0.01 || heightMM < 1 || heightPx < 1) {

     // Something extremely bogus is going on

     return 96.0f;

   }

   // Currently we don't do our own scaling to take account

   // of userSpaceScaleFactor, so every "pixel" we draw is actually

   // userSpaceScaleFactor screen pixels. So divide the screen height

   // by userSpaceScaleFactor to get the number of "device pixels"

   // available.

   float dpi = (heightPx / scaleFactor) / (heightMM / MM_PER_INCH_FLOAT);

   // Account for HiDPI mode where Cocoa's "points" do not correspond to real

   // device pixels

   CGFloat backingScale = GetBackingScaleFactor(aWindow);

   return dpi * backingScale;

 }

 @interface NSView(FrameViewMethodSwizzling)

 - (NSPoint)FrameView__closeButtonOrigin;

 - (NSPoint)FrameView__fullScreenButtonOrigin;

 @end

 @implementation NSView(FrameViewMethodSwizzling)

 - (NSPoint)FrameView__closeButtonOrigin

 {

   NSPoint defaultPosition = [self FrameView__closeButtonOrigin];

   if ([[self window] isKindOfClass:[ToolbarWindow class]]) {

     return [(ToolbarWindow*)[self window] windowButtonsPositionWithDefaultPosition:defaultPosition];

   }

   return defaultPosition;

 }

 - (NSPoint)FrameView__fullScreenButtonOrigin

 {

   NSPoint defaultPosition = [self FrameView__fullScreenButtonOrigin];

   if ([[self window] isKindOfClass:[ToolbarWindow class]]) {

     return [(ToolbarWindow*)[self window] fullScreenButtonPositionWithDefaultPosition:defaultPosition];

   }

   return defaultPosition;

 }

 @end

 static NSMutableSet *gSwizzledFrameViewClasses = nil;

 @interface NSWindow(PrivateSetNeedsDisplayInRectMethod)

  - (void)_setNeedsDisplayInRect:(NSRect)aRect;

 @end

 @interface BaseWindow(Private)

 - (void)removeTrackingArea;

 - (void)cursorUpdated:(NSEvent*)aEvent;

 - (void)updateContentViewSize;

 - (void)reflowTitlebarElements;

 @end

 @implementation BaseWindow

 // The frame of a window is implemented using undocumented NSView subclasses.

 // We offset the window buttons by overriding the methods _closeButtonOrigin

 // and _fullScreenButtonOrigin on these frame view classes. The class which is

 // used for a window is determined in the window's frameViewClassForStyleMask:

 // method, so this is where we make sure that we have swizzled the method on

 // all encountered classes.

 + (Class)frameViewClassForStyleMask:(NSUInteger)styleMask

 {

   Class frameViewClass = [super frameViewClassForStyleMask:styleMask];

   if (!gSwizzledFrameViewClasses) {

     gSwizzledFrameViewClasses = [[NSMutableSet setWithCapacity:3] retain];

     if (!gSwizzledFrameViewClasses) {

       return frameViewClass;

     }

   }

   static IMP our_closeButtonOrigin =

     class_getMethodImplementation([NSView class],

                                   @selector(FrameView__closeButtonOrigin));

   static IMP our_fullScreenButtonOrigin =

     class_getMethodImplementation([NSView class],

                                   @selector(FrameView__fullScreenButtonOrigin));

   if (![gSwizzledFrameViewClasses containsObject:frameViewClass]) {

     // Either of these methods might be implemented in both a subclass of

     // NSFrameView and one of its own subclasses.  Which means that if we

     // aren't careful we might end up swizzling the same method twice.

     // Since method swizzling involves swapping pointers, this would break

     // things.

     IMP _closeButtonOrigin =

       class_getMethodImplementation(frameViewClass,

                                     @selector(_closeButtonOrigin));

     if (_closeButtonOrigin && _closeButtonOrigin != our_closeButtonOrigin) {

       nsToolkit::SwizzleMethods(frameViewClass, @selector(_closeButtonOrigin),

                                 @selector(FrameView__closeButtonOrigin));

     }

     IMP _fullScreenButtonOrigin =

       class_getMethodImplementation(frameViewClass,

                                     @selector(_fullScreenButtonOrigin));

     if (_fullScreenButtonOrigin &&

         _fullScreenButtonOrigin != our_fullScreenButtonOrigin) {

       nsToolkit::SwizzleMethods(frameViewClass, @selector(_fullScreenButtonOrigin),

                                 @selector(FrameView__fullScreenButtonOrigin));

     }

     [gSwizzledFrameViewClasses addObject:frameViewClass];

   }

   return frameViewClass;

 }

 - (id)initWithContentRect:(NSRect)aContentRect styleMask:(NSUInteger)aStyle backing:(NSBackingStoreType)aBufferingType defer:(BOOL)aFlag

 {

   mDrawsIntoWindowFrame = NO;

   [super initWithContentRect:aContentRect styleMask:aStyle backing:aBufferingType defer:aFlag];

   mState = nil;

   mActiveTitlebarColor = nil;

   mInactiveTitlebarColor = nil;

   mScheduledShadowInvalidation = NO;

   mDisabledNeedsDisplay = NO;

   mDPI = GetDPI(self);

   mTrackingArea = nil;

   mBeingShown = NO;

   mDrawTitle = NO;

   [self updateTrackingArea];

   return self;

 }

 - (void)setBeingShown:(BOOL)aValue

 {

   mBeingShown = aValue;

 }

 - (BOOL)isBeingShown

 {

   return mBeingShown;

 }

 - (BOOL)isVisibleOrBeingShown

 {

   return [super isVisible] || mBeingShown;

 }

 - (void)disableSetNeedsDisplay

 {

   mDisabledNeedsDisplay = YES;

 }

 - (void)enableSetNeedsDisplay

 {

   mDisabledNeedsDisplay = NO;

 }