The Tor Browser: comparison widget/cocoa/nsCocoaWindow.mm

--1:000000000000
+:417dbd5a951a
+/* -*- 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;
+}
+- (void)dealloc
+{
+[mActiveTitlebarColor release];
+[mInactiveTitlebarColor release];
+[self removeTrackingArea];
+ChildViewMouseTracker::OnDestroyWindow(self);
+[super dealloc];
+}
+static const NSString* kStateTitleKey = @"title";
+static const NSString* kStateDrawsContentsIntoWindowFrameKey = @"drawsContentsIntoWindowFrame";
+static const NSString* kStateActiveTitlebarColorKey = @"activeTitlebarColor";
+static const NSString* kStateInactiveTitlebarColorKey = @"inactiveTitlebarColor";
+static const NSString* kStateShowsToolbarButton = @"showsToolbarButton";
+- (void)importState:(NSDictionary*)aState
+{
+[self setTitle:[aState objectForKey:kStateTitleKey]];
+[self setDrawsContentsIntoWindowFrame:[[aState objectForKey:kStateDrawsContentsIntoWindowFrameKey] boolValue]];
+[self setTitlebarColor:[aState objectForKey:kStateActiveTitlebarColorKey] forActiveWindow:YES];
+[self setTitlebarColor:[aState objectForKey:kStateInactiveTitlebarColorKey] forActiveWindow:NO];
+[self setShowsToolbarButton:[[aState objectForKey:kStateShowsToolbarButton] boolValue]];
+}
+- (NSMutableDictionary*)exportState
+{
+NSMutableDictionary* state = [NSMutableDictionary dictionaryWithCapacity:10];
+[state setObject:[self title] forKey:kStateTitleKey];
+[state setObject:[NSNumber numberWithBool:[self drawsContentsIntoWindowFrame]]
+forKey:kStateDrawsContentsIntoWindowFrameKey];
+NSColor* activeTitlebarColor = [self titlebarColorForActiveWindow:YES];
+if (activeTitlebarColor) {
+[state setObject:activeTitlebarColor forKey:kStateActiveTitlebarColorKey];
+}
+NSColor* inactiveTitlebarColor = [self titlebarColorForActiveWindow:NO];
+if (inactiveTitlebarColor) {
+[state setObject:inactiveTitlebarColor forKey:kStateInactiveTitlebarColorKey];
+}
+[state setObject:[NSNumber numberWithBool:[self showsToolbarButton]]
+forKey:kStateShowsToolbarButton];
+return state;
+}
+- (void)setDrawsContentsIntoWindowFrame:(BOOL)aState
+{
+bool changed = (aState != mDrawsIntoWindowFrame);
+mDrawsIntoWindowFrame = aState;
+if (changed) {
+[self updateContentViewSize];
+[self reflowTitlebarElements];
+}
+}
+- (BOOL)drawsContentsIntoWindowFrame
+{
+return mDrawsIntoWindowFrame;
+}
+- (void)setWantsTitleDrawn:(BOOL)aDrawTitle
+{
+mDrawTitle = aDrawTitle;
+}
+- (BOOL)wantsTitleDrawn
+{
+return mDrawTitle;
+}
+// Pass nil here to get the default appearance.
+- (void)setTitlebarColor:(NSColor*)aColor forActiveWindow:(BOOL)aActive
+{
+[aColor retain];
+if (aActive) {
+[mActiveTitlebarColor release];
+mActiveTitlebarColor = aColor;
+} else {
+[mInactiveTitlebarColor release];
+mInactiveTitlebarColor = aColor;
+}
+}
+- (NSColor*)titlebarColorForActiveWindow:(BOOL)aActive
+{
+return aActive ? mActiveTitlebarColor : mInactiveTitlebarColor;
+}
+- (void)deferredInvalidateShadow
+{
+if (mScheduledShadowInvalidation || [self isOpaque] || ![self hasShadow])
+return;
+[self performSelector:@selector(invalidateShadow) withObject:nil afterDelay:0];
+mScheduledShadowInvalidation = YES;
+}
+- (void)invalidateShadow
+{
+[super invalidateShadow];
+mScheduledShadowInvalidation = NO;
+}
+- (float)getDPI
+{
+return mDPI;
+}
+- (NSView*)trackingAreaView
+{
+NSView* contentView = [self contentView];
+return [contentView superview] ? [contentView superview] : contentView;
+}
+- (ChildView*)mainChildView
+{
+NSView *contentView = [self contentView];
+// A PopupWindow's contentView is a ChildView object.
+if ([contentView isKindOfClass:[ChildView class]]) {
+return (ChildView*)contentView;
+}
+NSView* lastView = [[contentView subviews] lastObject];
+if ([lastView isKindOfClass:[ChildView class]]) {
+return (ChildView*)lastView;
+}
+return nil;
+}
+- (void)removeTrackingArea
+{
+if (mTrackingArea) {
+[[self trackingAreaView] removeTrackingArea:mTrackingArea];
+[mTrackingArea release];
+mTrackingArea = nil;
+}
+}
+- (void)updateTrackingArea
+{
+[self removeTrackingArea];
+NSView* view = [self trackingAreaView];
+const NSTrackingAreaOptions options =
+NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved | NSTrackingActiveAlways;
+mTrackingArea = [[NSTrackingArea alloc] initWithRect:[view bounds]
+options:options
+owner:self
+userInfo:nil];
+[view addTrackingArea:mTrackingArea];
+}
+- (void)mouseEntered:(NSEvent*)aEvent
+{
+ChildViewMouseTracker::MouseEnteredWindow(aEvent);
+}
+- (void)mouseExited:(NSEvent*)aEvent
+{
+ChildViewMouseTracker::MouseExitedWindow(aEvent);
+}
+- (void)mouseMoved:(NSEvent*)aEvent
+{
+ChildViewMouseTracker::MouseMoved(aEvent);
+}
+- (void)cursorUpdated:(NSEvent*)aEvent
+{
+// Nothing to do here, but NSTrackingArea wants us to implement this method.
+}
+- (void)_setNeedsDisplayInRect:(NSRect)aRect
+{
+// Prevent unnecessary invalidations due to moving NSViews (e.g. for plugins)
+if (!mDisabledNeedsDisplay) {
+// This method is only called by Cocoa, so when we're here, we know that
+// it's available and don't need to check whether our superclass responds
+// to the selector.
+[super _setNeedsDisplayInRect:aRect];
+}
+}
+- (void)updateContentViewSize
+{
+NSRect rect = [self contentRectForFrameRect:[self frame]];
+[[self contentView] setFrameSize:rect.size];
+}
+// Possibly move the titlebar buttons.
+- (void)reflowTitlebarElements
+{
+NSView *frameView = [[self contentView] superview];
+if ([frameView respondsToSelector:@selector(_tileTitlebarAndRedisplay:)]) {
+[frameView _tileTitlebarAndRedisplay:NO];
+}
+}
+// Override methods that translate between content rect and frame rect.
+- (NSRect)contentRectForFrameRect:(NSRect)aRect
+{
+if ([self drawsContentsIntoWindowFrame]) {
+return aRect;
+}
+return [super contentRectForFrameRect:aRect];
+}
+- (NSRect)contentRectForFrameRect:(NSRect)aRect styleMask:(NSUInteger)aMask
+{
+if ([self drawsContentsIntoWindowFrame]) {
+return aRect;
+}
+if ([super respondsToSelector:@selector(contentRectForFrameRect:styleMask:)]) {
+return [super contentRectForFrameRect:aRect styleMask:aMask];
+} else {
+return [NSWindow contentRectForFrameRect:aRect styleMask:aMask];
+}
+}
+- (NSRect)frameRectForContentRect:(NSRect)aRect
+{
+if ([self drawsContentsIntoWindowFrame]) {
+return aRect;
+}
+return [super frameRectForContentRect:aRect];
+}
+- (NSRect)frameRectForContentRect:(NSRect)aRect styleMask:(NSUInteger)aMask
+{
+if ([self drawsContentsIntoWindowFrame]) {
+return aRect;
+}
+if ([super respondsToSelector:@selector(frameRectForContentRect:styleMask:)]) {
+return [super frameRectForContentRect:aRect styleMask:aMask];
+} else {
+return [NSWindow frameRectForContentRect:aRect styleMask:aMask];
+}
+}
+- (void)setContentView:(NSView*)aView
+{
+[super setContentView:aView];
+// Now move the contentView to the bottommost layer so that it's guaranteed
+// to be under the window buttons.
+NSView* frameView = [aView superview];
+[aView removeFromSuperview];
+[frameView addSubview:aView positioned:NSWindowBelow relativeTo:nil];
+}
+- (NSArray*)titlebarControls
+{
+// Return all subviews of the frameView which are not the content view.
+NSView* frameView = [[self contentView] superview];
+NSMutableArray* array = [[[frameView subviews] mutableCopy] autorelease];
+[array removeObject:[self contentView]];
+return array;
+}
+- (BOOL)respondsToSelector:(SEL)aSelector
+{
+// Claim the window doesn't respond to this so that the system
+// doesn't steal keyboard equivalents for it. Bug 613710.
+if (aSelector == @selector(cancelOperation:)) {
+return NO;
+}
+return [super respondsToSelector:aSelector];
+}
+- (void) doCommandBySelector:(SEL)aSelector
+{
+// We override this so that it won't beep if it can't act.
+// We want to control the beeping for missing or disabled
+// commands ourselves.
+[self tryToPerform:aSelector with:nil];
+}
+- (id)accessibilityAttributeValue:(NSString *)attribute
+{
+id retval = [super accessibilityAttributeValue:attribute];
+// The following works around a problem with Text-to-Speech on OS X 10.7.
+// See bug 674612 for more info.
+//
+// When accessibility is off, AXUIElementCopyAttributeValue(), when called
+// on an AXApplication object to get its AXFocusedUIElement attribute,
+// always returns an AXWindow object (the actual browser window -- never a
+// mozAccessible object).  This also happens with accessibility turned on,
+// if no other object in the browser window has yet been focused.  But if
+// the browser window has a title bar (as it currently always does), the
+// AXWindow object will always have four "accessible" children, one of which
+// is an AXStaticText object (the title bar's "title"; the other three are
+// the close, minimize and zoom buttons).  This means that (for complicated
+// reasons, for which see bug 674612) Text-to-Speech on OS X 10.7 will often
+// "speak" the window title, no matter what text is selected, or even if no
+// text at all is selected.  (This always happens when accessibility is off.
+// It doesn't happen in Firefox releases because Apple has (on OS X 10.7)
+// special-cased the handling of apps whose CFBundleIdentifier is
+// org.mozilla.firefox.)
+//
+// We work around this problem by only returning AXChildren that are
+// mozAccessible object or are one of the titlebar's buttons (which
+// instantiate subclasses of NSButtonCell).
+if (nsCocoaFeatures::OnLionOrLater() && [retval isKindOfClass:[NSArray class]] &&
+[attribute isEqualToString:@"AXChildren"]) {
+NSMutableArray *holder = [NSMutableArray arrayWithCapacity:10];
+[holder addObjectsFromArray:(NSArray *)retval];
+NSUInteger count = [holder count];
+for (NSInteger i = count - 1; i >= 0; --i) {
+id item = [holder objectAtIndex:i];
+// Remove anything from holder that isn't one of the titlebar's buttons
+// (which instantiate subclasses of NSButtonCell) or a mozAccessible
+// object (or one of its subclasses).
+if (![item isKindOfClass:[NSButtonCell class]] &&
+![item respondsToSelector:@selector(hasRepresentedView)]) {
+[holder removeObjectAtIndex:i];
+}
+}
+retval = [NSArray arrayWithArray:holder];
+}
+return retval;
+}
+// If we were built on OS X 10.6 or with the 10.6 SDK and are running on Lion,
+// the OS (specifically -[NSWindow sendEvent:]) won't send NSEventTypeGesture
+// events to -[ChildView magnifyWithEvent:] as it should.  The following code
+// gets around this.  See bug 863841.
+#if !defined( MAC_OS_X_VERSION_10_7 ) || \
+( MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7 )
+- (void)sendEvent:(NSEvent *)anEvent
+{
+if ([ChildView isLionSmartMagnifyEvent: anEvent]) {
+[[self mainChildView] magnifyWithEvent:anEvent];
+return;
+}
+[super sendEvent:anEvent];
+}
+#endif
+@end
+// This class allows us to exercise control over the window's title bar. This
+// allows for a "unified toolbar" look without having to extend the content
+// area into the title bar. It works like this:
+// 1) We set the window's style to textured.
+// 2) Because of this, the background color applies to the entire window, including
+//     the titlebar area. For normal textured windows, the default pattern is a
+//    "brushed metal" image on Tiger and a unified gradient on Leopard.
+// 3) We set the background color to a custom NSColor subclass that knows how tall the window is.
+//    When -set is called on it, it sets a pattern (with a draw callback) as the fill. In that callback,
+//    it paints the the titlebar and background colors in the correct areas of the context it's given,
+//    which will fill the entire window (CG will tile it horizontally for us).
+// 4) Whenever the window's main state changes and when [window display] is called,
+//    Cocoa redraws the titlebar using the patternDraw callback function.
+//
+// This class also provides us with a pill button to show/hide the toolbar up to 10.6.
+//
+// Drawing the unified gradient in the titlebar and the toolbar works like this:
+// 1) In the style sheet we set the toolbar's -moz-appearance to toolbar or
+//    -moz-mac-unified-toolbar.
+// 2) When the toolbar is visible and we paint the application chrome
+//    window, the array that Gecko passes nsChildView::UpdateThemeGeometries
+//    will contain an entry for the widget type NS_THEME_TOOLBAR or
+//    NS_THEME_MOZ_MAC_UNIFIED_TOOLBAR.
+// 3) nsChildView::UpdateThemeGeometries finds the toolbar frame's ToolbarWindow
+//    and passes the toolbar frame's height to setUnifiedToolbarHeight.
+// 4) If the toolbar height has changed, a titlebar redraw is triggered and the
+//    upper part of the unified gradient is drawn in the titlebar.
+// 5) The lower part of the unified gradient in the toolbar is drawn during
+//    normal window content painting in nsNativeThemeCocoa::DrawUnifiedToolbar.
+//
+// Whenever the unified gradient is drawn in the titlebar or the toolbar, both
+// titlebar height and toolbar height must be known in order to construct the
+// correct gradient. But you can only get from the toolbar frame
+// to the containing window - the other direction doesn't work. That's why the
+// toolbar height is cached in the ToolbarWindow but nsNativeThemeCocoa can simply
+// query the window for its titlebar height when drawing the toolbar.
+//
+// Note that in drawsContentsIntoWindowFrame mode, titlebar drawing works in a
+// completely different way: In that mode, the window's mainChildView will
+// cover the titlebar completely and nothing that happens in the window
+// background will reach the screen.
+@implementation ToolbarWindow
+- (id)initWithContentRect:(NSRect)aContentRect styleMask:(NSUInteger)aStyle backing:(NSBackingStoreType)aBufferingType defer:(BOOL)aFlag
+{
+NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+aStyle = aStyle | NSTexturedBackgroundWindowMask;
+if ((self = [super initWithContentRect:aContentRect styleMask:aStyle backing:aBufferingType defer:aFlag])) {
+mColor = [[TitlebarAndBackgroundColor alloc] initWithWindow:self];
+// Bypass our guard method below.
+[super setBackgroundColor:mColor];
+mBackgroundColor = [[NSColor whiteColor] retain];
+mUnifiedToolbarHeight = 22.0f;
+mWindowButtonsRect = NSZeroRect;
+mFullScreenButtonRect = NSZeroRect;
+// setBottomCornerRounded: is a private API call, so we check to make sure
+// we respond to it just in case.
+if ([self respondsToSelector:@selector(setBottomCornerRounded:)])
+[self setBottomCornerRounded:nsCocoaFeatures::OnLionOrLater()];
+[self setAutorecalculatesContentBorderThickness:NO forEdge:NSMaxYEdge];
+[self setContentBorderThickness:0.0f forEdge:NSMaxYEdge];
+}
+return self;
+NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+- (void)dealloc
+{
+NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
+[mColor release];
+[mBackgroundColor release];
+[mTitlebarView release];
+[super dealloc];
+NS_OBJC_END_TRY_ABORT_BLOCK;
+}
+- (void)setTitlebarColor:(NSColor*)aColor forActiveWindow:(BOOL)aActive
+{
+[super setTitlebarColor:aColor forActiveWindow:aActive];
+[self setTitlebarNeedsDisplayInRect:[self titlebarRect]];
+}
+- (void)setBackgroundColor:(NSColor*)aColor
+{
+[aColor retain];
+[mBackgroundColor release];
+mBackgroundColor = aColor;
+}
+- (NSColor*)windowBackgroundColor
+{
+return mBackgroundColor;
+}
+- (void)setTitlebarNeedsDisplayInRect:(NSRect)aRect
+{
+[self setTitlebarNeedsDisplayInRect:aRect sync:NO];
+}
+- (void)setTitlebarNeedsDisplayInRect:(NSRect)aRect sync:(BOOL)aSync
+{
+NSRect titlebarRect = [self titlebarRect];
+NSRect rect = NSIntersectionRect(titlebarRect, aRect);
+if (NSIsEmptyRect(rect))
+return;
+NSView* borderView = [[self contentView] superview];
+if (!borderView)
+return;
+if (aSync) {
+[borderView displayRect:rect];
+} else {
+[borderView setNeedsDisplayInRect:rect];
+}
+}
+- (NSRect)titlebarRect
+{
+CGFloat titlebarHeight = [self titlebarHeight];
+return NSMakeRect(0, [self frame].size.height - titlebarHeight,
+[self frame].size.width, titlebarHeight);
+}
+// Returns the unified height of titlebar + toolbar.
+- (CGFloat)unifiedToolbarHeight
+{
+return mUnifiedToolbarHeight;
+}
+- (CGFloat)titlebarHeight
+{
+// We use the original content rect here, not what we return from
+// [self contentRectForFrameRect:], because that would give us a
+// titlebarHeight of zero in drawsContentsIntoWindowFrame mode.
+NSRect frameRect = [self frame];
+NSRect originalContentRect = [NSWindow contentRectForFrameRect:frameRect styleMask:[self styleMask]];
+return NSMaxY(frameRect) - NSMaxY(originalContentRect);
+}
+// Stores the complete height of titlebar + toolbar.
+- (void)setUnifiedToolbarHeight:(CGFloat)aHeight
+{
+if (aHeight == mUnifiedToolbarHeight)
+return;
+mUnifiedToolbarHeight = aHeight;
+// Update sheet positioning hint
+CGFloat topMargin = mUnifiedToolbarHeight - [self titlebarHeight];
+[self setContentBorderThickness:topMargin forEdge:NSMaxYEdge];
+// Redraw the title bar. If we're inside painting, we'll do it right now,
+// otherwise we'll just invalidate it.
+BOOL needSyncRedraw = ([NSView focusView] != nil);
+[self setTitlebarNeedsDisplayInRect:[self titlebarRect] sync:needSyncRedraw];
+}
+// Extending the content area into the title bar works by resizing the
+// mainChildView so that it covers the titlebar.
+- (void)setDrawsContentsIntoWindowFrame:(BOOL)aState
+{
+BOOL stateChanged = ([self drawsContentsIntoWindowFrame] != aState);
+[super setDrawsContentsIntoWindowFrame:aState];
+if (stateChanged && [[self delegate] isKindOfClass:[WindowDelegate class]]) {
+// Here we extend / shrink our mainChildView. We do that by firing a resize
+// event which will cause the ChildView to be resized to the rect returned
+// by nsCocoaWindow::GetClientBounds. GetClientBounds bases its return
+// value on what we return from drawsContentsIntoWindowFrame.
+WindowDelegate *windowDelegate = (WindowDelegate *)[self delegate];
+nsCocoaWindow *geckoWindow = [windowDelegate geckoWidget];
+if (geckoWindow) {
+// Re-layout our contents.
+geckoWindow->ReportSizeEvent();
+}
+// Resizing the content area causes a reflow which would send a synthesized
+// mousemove event to the old mouse position relative to the top left
+// corner of the content area. But the mouse has shifted relative to the
+// content area, so that event would have wrong position information. So
+// we'll send a mouse move event with the correct new position.
+ChildViewMouseTracker::ResendLastMouseMoveEvent();
+}
+}
+- (void)setWantsTitleDrawn:(BOOL)aDrawTitle
+{
+[super setWantsTitleDrawn:aDrawTitle];
+[self setTitlebarNeedsDisplayInRect:[self titlebarRect]];
+}
+- (void)placeWindowButtons:(NSRect)aRect
+{
+if (!NSEqualRects(mWindowButtonsRect, aRect)) {
+mWindowButtonsRect = aRect;
+[self reflowTitlebarElements];
+}
+}
+- (NSPoint)windowButtonsPositionWithDefaultPosition:(NSPoint)aDefaultPosition
+{
+if ([self drawsContentsIntoWindowFrame] && !NSIsEmptyRect(mWindowButtonsRect)) {
+return NSMakePoint(std::max(mWindowButtonsRect.origin.x, aDefaultPosition.x),
+std::min(mWindowButtonsRect.origin.y, aDefaultPosition.y));
+}
+return aDefaultPosition;
+}
+- (void)placeFullScreenButton:(NSRect)aRect
+{
+if (!NSEqualRects(mFullScreenButtonRect, aRect)) {
+mFullScreenButtonRect = aRect;
+[self reflowTitlebarElements];
+}
+}
+- (NSPoint)fullScreenButtonPositionWithDefaultPosition:(NSPoint)aDefaultPosition;
+{
+if ([self drawsContentsIntoWindowFrame] && !NSIsEmptyRect(mFullScreenButtonRect)) {
+return NSMakePoint(std::min(mFullScreenButtonRect.origin.x, aDefaultPosition.x),
+std::min(mFullScreenButtonRect.origin.y, aDefaultPosition.y));
+}
+return aDefaultPosition;
+}
+// Returning YES here makes the setShowsToolbarButton method work even though
+// the window doesn't contain an NSToolbar.
+- (BOOL)_hasToolbar
+{
+return YES;
+}
+// Dispatch a toolbar pill button clicked message to Gecko.
+- (void)_toolbarPillButtonClicked:(id)sender
+{
+NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
+RollUpPopups();
+if ([[self delegate] isKindOfClass:[WindowDelegate class]]) {
+WindowDelegate *windowDelegate = (WindowDelegate *)[self delegate];
+nsCocoaWindow *geckoWindow = [windowDelegate geckoWidget];
+if (!geckoWindow)
+return;
+nsIWidgetListener* listener = geckoWindow->GetWidgetListener();
+if (listener)
+listener->OSToolbarButtonPressed();
+}
+NS_OBJC_END_TRY_ABORT_BLOCK;
+}
+// Retain and release "self" to avoid crashes when our widget (and its native
+// window) is closed as a result of processing a key equivalent (e.g.
+// Command+w or Command+q).  This workaround is only needed for a window
+// that can become key.
+- (BOOL)performKeyEquivalent:(NSEvent*)theEvent
+{
+NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
+NSWindow *nativeWindow = [self retain];
+BOOL retval = [super performKeyEquivalent:theEvent];
+[nativeWindow release];
+return retval;
+NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
+}
+- (void)sendEvent:(NSEvent *)anEvent
+{
+NSEventType type = [anEvent type];
+switch (type) {
+case NSScrollWheel:
+case NSLeftMouseDown:
+case NSLeftMouseUp:
+case NSRightMouseDown:
+case NSRightMouseUp:
+case NSOtherMouseDown:
+case NSOtherMouseUp:
+case NSMouseMoved:
+case NSLeftMouseDragged:
+case NSRightMouseDragged:
+case NSOtherMouseDragged:
+{
+// Drop all mouse events if a modal window has appeared above us.
+// This helps make us behave as if the OS were running a "real" modal
+// event loop.
+id delegate = [self delegate];
+if (delegate && [delegate isKindOfClass:[WindowDelegate class]]) {
+nsCocoaWindow *widget = [(WindowDelegate *)delegate geckoWidget];
+if (widget) {
+if (type == NSMouseMoved) {
+[[self mainChildView] updateWindowDraggableStateOnMouseMove:anEvent];
+}
+if (gGeckoAppModalWindowList && (widget != gGeckoAppModalWindowList->window))
+return;
+if (widget->HasModalDescendents())
+return;
+}
+}
+break;
+}
+default:
+break;
+}
+[super sendEvent:anEvent];
+}
+@end
+// Custom NSColor subclass where most of the work takes place for drawing in
+// the titlebar area. Not used in drawsContentsIntoWindowFrame mode.
+@implementation TitlebarAndBackgroundColor
+- (id)initWithWindow:(ToolbarWindow*)aWindow
+{
+if ((self = [super init])) {
+mWindow = aWindow; // weak ref to avoid a cycle
+}
+return self;
+}
+static void
+DrawNativeTitlebar(CGContextRef aContext, CGRect aTitlebarRect,
+CGFloat aUnifiedToolbarHeight, BOOL aIsMain)
+{
+if (aTitlebarRect.size.width * aTitlebarRect.size.height > CUIDRAW_MAX_AREA) {
+return;
+}
+CUIDraw([NSWindow coreUIRenderer], aTitlebarRect, aContext,
+(CFDictionaryRef)[NSDictionary dictionaryWithObjectsAndKeys:
+@"kCUIWidgetWindowFrame", @"widget",
+@"regularwin", @"windowtype",
+(aIsMain ? @"normal" : @"inactive"), @"state",
+[NSNumber numberWithDouble:aUnifiedToolbarHeight], @"kCUIWindowFrameUnifiedTitleBarHeightKey",
+[NSNumber numberWithBool:YES], @"kCUIWindowFrameDrawTitleSeparatorKey",
+nil],
+nil);
+if (nsCocoaFeatures::OnLionOrLater()) {
+// On Lion the call to CUIDraw doesn't draw the top pixel strip at some
+// window widths. We don't want to have a flickering transparent line, so
+// we overdraw it.
+CGContextSetRGBFillColor(aContext, 0.95, 0.95, 0.95, 1);
+CGContextFillRect(aContext, CGRectMake(0, CGRectGetMaxY(aTitlebarRect) - 1,
+aTitlebarRect.size.width, 1));
+}
+}
+// Pattern draw callback for standard titlebar gradients and solid titlebar colors
+static void
+TitlebarDrawCallback(void* aInfo, CGContextRef aContext)
+{
+ToolbarWindow *window = (ToolbarWindow*)aInfo;
+if (![window drawsContentsIntoWindowFrame]) {
+NSRect titlebarRect = [window titlebarRect];
+BOOL isMain = [window isMainWindow];
+NSColor *titlebarColor = [window titlebarColorForActiveWindow:isMain];
+if (!titlebarColor) {
+// If the titlebar color is nil, draw the default titlebar shading.
+DrawNativeTitlebar(aContext, NSRectToCGRect(titlebarRect),
+[window unifiedToolbarHeight], isMain);
+} else {
+// If the titlebar color is not nil, just set and draw it normally.
+[NSGraphicsContext saveGraphicsState];
+[NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithGraphicsPort:aContext flipped:NO]];
+[titlebarColor set];
+NSRectFill(titlebarRect);
+[NSGraphicsContext restoreGraphicsState];
+}
+}
+}
+- (void)setFill
+{
+float patternWidth = [mWindow frame].size.width;
+CGPatternCallbacks callbacks = {0, &TitlebarDrawCallback, NULL};
+CGPatternRef pattern = CGPatternCreate(mWindow, CGRectMake(0.0f, 0.0f, patternWidth, [mWindow frame].size.height),
+CGAffineTransformIdentity, patternWidth, [mWindow frame].size.height,
+kCGPatternTilingConstantSpacing, true, &callbacks);
+// Set the pattern as the fill, which is what we were asked to do. All our
+// drawing will take place in the patternDraw callback.
+CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(NULL);
+CGContextRef context = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
+CGContextSetFillColorSpace(context, patternSpace);
+CGColorSpaceRelease(patternSpace);
+CGFloat component = 1.0f;
+CGContextSetFillPattern(context, pattern, &component);
+CGPatternRelease(pattern);
+}
+- (void)set
+{
+[self setFill];
+}
+- (NSString*)colorSpaceName
+{
+return NSDeviceRGBColorSpace;
+}
+@end
+@implementation PopupWindow
+- (id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)styleMask
+backing:(NSBackingStoreType)bufferingType defer:(BOOL)deferCreation
+{
+NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+mIsContextMenu = false;
+return [super initWithContentRect:contentRect styleMask:styleMask
+backing:bufferingType defer:deferCreation];
+NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+- (BOOL)isContextMenu
+{
+return mIsContextMenu;
+}
+- (void)setIsContextMenu:(BOOL)flag
+{
+mIsContextMenu = flag;
+}
+- (BOOL)canBecomeMainWindow
+{
+// This is overriden because the default is 'yes' when a titlebar is present.
+return NO;
+}
+@end
+// According to Apple's docs on [NSWindow canBecomeKeyWindow] and [NSWindow
+// canBecomeMainWindow], windows without a title bar or resize bar can't (by
+// default) become key or main.  But if a window can't become key, it can't
+// accept keyboard input (bmo bug 393250).  And it should also be possible for
+// an otherwise "ordinary" window to become main.  We need to override these
+// two methods to make this happen.
+@implementation BorderlessWindow
+- (BOOL)canBecomeKeyWindow
+{
+return YES;
+}
+- (void)sendEvent:(NSEvent *)anEvent
+{
+NSEventType type = [anEvent type];
+switch (type) {
+case NSScrollWheel:
+case NSLeftMouseDown:
+case NSLeftMouseUp:
+case NSRightMouseDown:
+case NSRightMouseUp:
+case NSOtherMouseDown:
+case NSOtherMouseUp:
+case NSMouseMoved:
+case NSLeftMouseDragged:
+case NSRightMouseDragged:
+case NSOtherMouseDragged:
+{
+// Drop all mouse events if a modal window has appeared above us.
+// This helps make us behave as if the OS were running a "real" modal
+// event loop.
+id delegate = [self delegate];
+if (delegate && [delegate isKindOfClass:[WindowDelegate class]]) {
+nsCocoaWindow *widget = [(WindowDelegate *)delegate geckoWidget];
+if (widget) {
+if (gGeckoAppModalWindowList && (widget != gGeckoAppModalWindowList->window))
+return;
+if (widget->HasModalDescendents())
+return;
+}
+}
+break;
+}
+default:
+break;
+}
+[super sendEvent:anEvent];
+}
+// Apple's doc on this method says that the NSWindow class's default is not to
+// become main if the window isn't "visible" -- so we should replicate that
+// behavior here.  As best I can tell, the [NSWindow isVisible] method is an
+// accurate test of what Apple means by "visibility".
+- (BOOL)canBecomeMainWindow
+{
+NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
+if (![self isVisible])
+return NO;
+return YES;
+NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
+}
+// Retain and release "self" to avoid crashes when our widget (and its native
+// window) is closed as a result of processing a key equivalent (e.g.
+// Command+w or Command+q).  This workaround is only needed for a window
+// that can become key.
+- (BOOL)performKeyEquivalent:(NSEvent*)theEvent
+{
+NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
+NSWindow *nativeWindow = [self retain];
+BOOL retval = [super performKeyEquivalent:theEvent];
+[nativeWindow release];
+return retval;
+NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
+}
+@end

The Tor Browser / file comparison

comparison: widget/cocoa/nsCocoaWindow.mm

widget/cocoa/nsCocoaWindow.mm