From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- xpfe/appshell/nsXULWindow.cpp | 2334 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2334 insertions(+) create mode 100644 xpfe/appshell/nsXULWindow.cpp (limited to 'xpfe/appshell/nsXULWindow.cpp') diff --git a/xpfe/appshell/nsXULWindow.cpp b/xpfe/appshell/nsXULWindow.cpp new file mode 100644 index 000000000..8f2d9fde5 --- /dev/null +++ b/xpfe/appshell/nsXULWindow.cpp @@ -0,0 +1,2334 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 ci et: */ +/* 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 "mozilla/MathAlgorithms.h" + +// Local includes +#include "nsXULWindow.h" +#include + +// Helper classes +#include "nsPrintfCString.h" +#include "nsString.h" +#include "nsWidgetsCID.h" +#include "nsThreadUtils.h" +#include "nsNetCID.h" +#include "nsQueryObject.h" +#include "mozilla/Sprintf.h" + +//Interfaces needed to be included +#include "nsIAppShell.h" +#include "nsIAppShellService.h" +#include "nsIServiceManager.h" +#include "nsIContentViewer.h" +#include "nsIDocument.h" +#include "nsIDOMDocument.h" +#include "nsIDOMXULDocument.h" +#include "nsIDOMElement.h" +#include "nsIDOMXULElement.h" +#include "nsPIDOMWindow.h" +#include "nsIDOMScreen.h" +#include "nsIEmbeddingSiteWindow.h" +#include "nsIInterfaceRequestor.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIIOService.h" +#include "nsILoadContext.h" +#include "nsIObserverService.h" +#include "nsIWindowMediator.h" +#include "nsIScreenManager.h" +#include "nsIScreen.h" +#include "nsIScrollable.h" +#include "nsIScriptSecurityManager.h" +#include "nsIWindowWatcher.h" +#include "nsIURI.h" +#include "nsIDOMCSSStyleDeclaration.h" +#include "nsAppShellCID.h" +#include "nsReadableUtils.h" +#include "nsStyleConsts.h" +#include "nsPresContext.h" +#include "nsContentUtils.h" +#include "nsWebShellWindow.h" // get rid of this one, too... +#include "nsGlobalWindow.h" + +#include "prenv.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/Preferences.h" +#include "mozilla/Services.h" +#include "mozilla/dom/BarProps.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/TabParent.h" + +using namespace mozilla; +using dom::AutoNoJSAPI; + +#define SIZEMODE_NORMAL NS_LITERAL_STRING("normal") +#define SIZEMODE_MAXIMIZED NS_LITERAL_STRING("maximized") +#define SIZEMODE_MINIMIZED NS_LITERAL_STRING("minimized") +#define SIZEMODE_FULLSCREEN NS_LITERAL_STRING("fullscreen") + +#define WINDOWTYPE_ATTRIBUTE NS_LITERAL_STRING("windowtype") + +#define PERSIST_ATTRIBUTE NS_LITERAL_STRING("persist") +#define SCREENX_ATTRIBUTE NS_LITERAL_STRING("screenX") +#define SCREENY_ATTRIBUTE NS_LITERAL_STRING("screenY") +#define WIDTH_ATTRIBUTE NS_LITERAL_STRING("width") +#define HEIGHT_ATTRIBUTE NS_LITERAL_STRING("height") +#define MODE_ATTRIBUTE NS_LITERAL_STRING("sizemode") +#define ZLEVEL_ATTRIBUTE NS_LITERAL_STRING("zlevel") + + +//***************************************************************************** +//*** nsXULWindow: Object Management +//***************************************************************************** + +nsXULWindow::nsXULWindow(uint32_t aChromeFlags) + : mChromeTreeOwner(nullptr), + mContentTreeOwner(nullptr), + mPrimaryContentTreeOwner(nullptr), + mModalStatus(NS_OK), + mContinueModalLoop(false), + mDebuting(false), + mChromeLoaded(false), + mShowAfterLoad(false), + mIntrinsicallySized(false), + mCenterAfterLoad(false), + mIsHiddenWindow(false), + mLockedUntilChromeLoad(false), + mIgnoreXULSize(false), + mIgnoreXULPosition(false), + mChromeFlagsFrozen(false), + mIgnoreXULSizeMode(false), + mDestroying(false), + mRegistered(false), + mContextFlags(0), + mPersistentAttributesDirty(0), + mPersistentAttributesMask(0), + mChromeFlags(aChromeFlags) +{ +} + +nsXULWindow::~nsXULWindow() +{ + Destroy(); +} + +//***************************************************************************** +// nsXULWindow::nsISupports +//***************************************************************************** + +NS_IMPL_ADDREF(nsXULWindow) +NS_IMPL_RELEASE(nsXULWindow) + +NS_INTERFACE_MAP_BEGIN(nsXULWindow) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXULWindow) + NS_INTERFACE_MAP_ENTRY(nsIXULWindow) + NS_INTERFACE_MAP_ENTRY(nsIBaseWindow) + NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) + if (aIID.Equals(NS_GET_IID(nsXULWindow))) + foundInterface = reinterpret_cast(this); + else +NS_INTERFACE_MAP_END + +//***************************************************************************** +// nsXULWindow::nsIIntefaceRequestor +//***************************************************************************** + +NS_IMETHODIMP nsXULWindow::GetInterface(const nsIID& aIID, void** aSink) +{ + nsresult rv; + + NS_ENSURE_ARG_POINTER(aSink); + + if (aIID.Equals(NS_GET_IID(nsIPrompt))) { + rv = EnsurePrompter(); + if (NS_FAILED(rv)) return rv; + return mPrompter->QueryInterface(aIID, aSink); + } + if (aIID.Equals(NS_GET_IID(nsIAuthPrompt))) { + rv = EnsureAuthPrompter(); + if (NS_FAILED(rv)) return rv; + return mAuthPrompter->QueryInterface(aIID, aSink); + } + if (aIID.Equals(NS_GET_IID(mozIDOMWindowProxy))) { + return GetWindowDOMWindow(reinterpret_cast(aSink)); + } + if (aIID.Equals(NS_GET_IID(nsIDOMWindow))) { + nsCOMPtr window = nullptr; + rv = GetWindowDOMWindow(getter_AddRefs(window)); + nsCOMPtr domWindow = do_QueryInterface(window); + domWindow.forget(aSink); + return rv; + } + if (aIID.Equals(NS_GET_IID(nsIDOMWindowInternal))) { + nsCOMPtr window = nullptr; + rv = GetWindowDOMWindow(getter_AddRefs(window)); + nsCOMPtr domWindowInternal = do_QueryInterface(window); + domWindowInternal.forget(aSink); + return rv; + } + if (aIID.Equals(NS_GET_IID(nsIWebBrowserChrome)) && + NS_SUCCEEDED(EnsureContentTreeOwner()) && + NS_SUCCEEDED(mContentTreeOwner->QueryInterface(aIID, aSink))) + return NS_OK; + + if (aIID.Equals(NS_GET_IID(nsIEmbeddingSiteWindow)) && + NS_SUCCEEDED(EnsureContentTreeOwner()) && + NS_SUCCEEDED(mContentTreeOwner->QueryInterface(aIID, aSink))) + return NS_OK; + + return QueryInterface(aIID, aSink); +} + +//***************************************************************************** +// nsXULWindow::nsIXULWindow +//***************************************************************************** + +NS_IMETHODIMP nsXULWindow::GetDocShell(nsIDocShell** aDocShell) +{ + NS_ENSURE_ARG_POINTER(aDocShell); + + *aDocShell = mDocShell; + NS_IF_ADDREF(*aDocShell); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetZLevel(uint32_t *outLevel) +{ + nsCOMPtr mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (mediator) + mediator->GetZLevel(this, outLevel); + else + *outLevel = normalZ; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetZLevel(uint32_t aLevel) +{ + nsCOMPtr mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (!mediator) + return NS_ERROR_FAILURE; + + uint32_t zLevel; + mediator->GetZLevel(this, &zLevel); + if (zLevel == aLevel) + return NS_OK; + + /* refuse to raise a maximized window above the normal browser level, + for fear it could hide newly opened browser windows */ + if (aLevel > nsIXULWindow::normalZ && mWindow) { + nsSizeMode sizeMode = mWindow->SizeMode(); + if (sizeMode == nsSizeMode_Maximized || sizeMode == nsSizeMode_Fullscreen) { + return NS_ERROR_FAILURE; + } + } + + // do it + mediator->SetZLevel(this, aLevel); + PersistentAttributesDirty(PAD_MISC); + SavePersistentAttributes(); + + nsCOMPtr cv; + mDocShell->GetContentViewer(getter_AddRefs(cv)); + if (cv) { + nsCOMPtr doc = cv->GetDocument(); + if (doc) { + ErrorResult rv; + RefPtr event = + doc->CreateEvent(NS_LITERAL_STRING("Events"),rv); + if (event) { + event->InitEvent(NS_LITERAL_STRING("windowZLevel"), true, false); + + event->SetTrusted(true); + + bool defaultActionEnabled; + doc->DispatchEvent(event, &defaultActionEnabled); + } + } + } + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetContextFlags(uint32_t *aContextFlags) +{ + NS_ENSURE_ARG_POINTER(aContextFlags); + *aContextFlags = mContextFlags; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetContextFlags(uint32_t aContextFlags) +{ + mContextFlags = aContextFlags; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetChromeFlags(uint32_t *aChromeFlags) +{ + NS_ENSURE_ARG_POINTER(aChromeFlags); + *aChromeFlags = mChromeFlags; + /* mChromeFlags is kept up to date, except for scrollbar visibility. + That can be changed directly by the content DOM window, which + doesn't know to update the chrome window. So that we must check + separately. */ + + // however, it's pointless to ask if the window isn't set up yet + if (!mChromeLoaded) + return NS_OK; + + if (GetContentScrollbarVisibility()) + *aChromeFlags |= nsIWebBrowserChrome::CHROME_SCROLLBARS; + else + *aChromeFlags &= ~nsIWebBrowserChrome::CHROME_SCROLLBARS; + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetChromeFlags(uint32_t aChromeFlags) +{ + NS_ASSERTION(!mChromeFlagsFrozen, + "SetChromeFlags() after AssumeChromeFlagsAreFrozen()!"); + + mChromeFlags = aChromeFlags; + if (mChromeLoaded) + NS_ENSURE_SUCCESS(ApplyChromeFlags(), NS_ERROR_FAILURE); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::AssumeChromeFlagsAreFrozen() +{ + mChromeFlagsFrozen = true; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetIntrinsicallySized(bool aIntrinsicallySized) +{ + mIntrinsicallySized = aIntrinsicallySized; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetIntrinsicallySized(bool* aIntrinsicallySized) +{ + NS_ENSURE_ARG_POINTER(aIntrinsicallySized); + + *aIntrinsicallySized = mIntrinsicallySized; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetPrimaryContentShell(nsIDocShellTreeItem** + aDocShellTreeItem) +{ + NS_ENSURE_ARG_POINTER(aDocShellTreeItem); + NS_IF_ADDREF(*aDocShellTreeItem = mPrimaryContentShell); + return NS_OK; +} + +NS_IMETHODIMP +nsXULWindow::TabParentAdded(nsITabParent* aTab, bool aPrimary) +{ + if (aPrimary) { + mPrimaryTabParent = aTab; + mPrimaryContentShell = nullptr; + } else if (mPrimaryTabParent == aTab) { + mPrimaryTabParent = nullptr; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsXULWindow::TabParentRemoved(nsITabParent* aTab) +{ + if (aTab == mPrimaryTabParent) { + mPrimaryTabParent = nullptr; + } + + return NS_OK; +} + +NS_IMETHODIMP +nsXULWindow::GetPrimaryTabParent(nsITabParent** aTab) +{ + nsCOMPtr tab = mPrimaryTabParent; + tab.forget(aTab); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetContentShellById(const char16_t* aID, + nsIDocShellTreeItem** aDocShellTreeItem) +{ + NS_ENSURE_ARG_POINTER(aDocShellTreeItem); + *aDocShellTreeItem = nullptr; + + uint32_t count = mContentShells.Length(); + for (uint32_t i = 0; i < count; i++) { + nsContentShellInfo* shellInfo = mContentShells.ElementAt(i); + if (shellInfo->id.Equals(aID)) { + *aDocShellTreeItem = nullptr; + if (shellInfo->child) + CallQueryReferent(shellInfo->child.get(), aDocShellTreeItem); + return NS_OK; + } + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP nsXULWindow::AddChildWindow(nsIXULWindow *aChild) +{ + // we're not really keeping track of this right now + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::RemoveChildWindow(nsIXULWindow *aChild) +{ + // we're not really keeping track of this right now + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::ShowModal() +{ + PROFILER_LABEL_FUNC(js::ProfileEntry::Category::OTHER); + + // Store locally so it doesn't die on us + nsCOMPtr window = mWindow; + nsCOMPtr tempRef = this; + + window->SetModal(true); + mContinueModalLoop = true; + EnableParent(false); + + { + AutoNoJSAPI nojsapi; + nsIThread *thread = NS_GetCurrentThread(); + while (mContinueModalLoop) { + if (!NS_ProcessNextEvent(thread)) + break; + } + } + + mContinueModalLoop = false; + window->SetModal(false); + /* Note there's no EnableParent(true) here to match the false one + above. That's done in ExitModalLoop. It's important that the parent + be re-enabled before this window is made invisible; to do otherwise + causes bizarre z-ordering problems. At this point, the window is + already invisible. + No known current implementation of Enable would have a problem with + re-enabling the parent twice, so we could do it again here without + breaking any current implementation. But that's unnecessary if the + modal loop is always exited using ExitModalLoop (the other way would be + to change the protected member variable directly.) + */ + + return mModalStatus; +} + +//***************************************************************************** +// nsXULWindow::nsIBaseWindow +//***************************************************************************** + +NS_IMETHODIMP nsXULWindow::InitWindow(nativeWindow aParentNativeWindow, + nsIWidget* parentWidget, int32_t x, int32_t y, int32_t cx, int32_t cy) +{ + //XXX First Check In + NS_ASSERTION(false, "Not Yet Implemented"); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::Create() +{ + //XXX First Check In + NS_ASSERTION(false, "Not Yet Implemented"); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::Destroy() +{ + if (!mWindow) + return NS_OK; + + // Ensure we don't reenter this code + if (mDestroying) + return NS_OK; + + mozilla::AutoRestore guard(mDestroying); + mDestroying = true; + + nsCOMPtr appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID)); + NS_ASSERTION(appShell, "Couldn't get appShell... xpcom shutdown?"); + if (appShell) + appShell->UnregisterTopLevelWindow(static_cast(this)); + + nsCOMPtr parentWindow(do_QueryReferent(mParentWindow)); + if (parentWindow) + parentWindow->RemoveChildWindow(this); + + // let's make sure the window doesn't get deleted out from under us + // while we are trying to close....this can happen if the docshell + // we close ends up being the last owning reference to this xulwindow + + // XXXTAB This shouldn't be an issue anymore because the ownership model + // only goes in one direction. When webshell container is fully removed + // try removing this... + + nsCOMPtr placeHolder = this; + + // Remove modality (if any) and hide while destroying. More than + // a convenience, the hide prevents user interaction with the partially + // destroyed window. This is especially necessary when the eldest window + // in a stack of modal windows is destroyed first. It happens. + ExitModalLoop(NS_OK); + // XXX: Skip unmapping the window on Linux due to GLX hangs on the compositor + // thread with NVIDIA driver 310.32. We don't need to worry about user + // interactions with destroyed windows on X11 either. +#ifndef MOZ_WIDGET_GTK + if (mWindow) + mWindow->Show(false); +#endif + +#if defined(XP_WIN) + // We need to explicitly set the focus on Windows, but + // only if the parent is visible. + nsCOMPtr parent(do_QueryReferent(mParentWindow)); + if (parent) { + nsCOMPtr parentWidget; + parent->GetMainWidget(getter_AddRefs(parentWidget)); + if (!parentWidget || parentWidget->IsVisible()) { + nsCOMPtr baseHiddenWindow; + if (appShell) { + nsCOMPtr hiddenWindow; + appShell->GetHiddenWindow(getter_AddRefs(hiddenWindow)); + if (hiddenWindow) + baseHiddenWindow = do_GetInterface(hiddenWindow); + } + // somebody screwed up somewhere. hiddenwindow shouldn't be anybody's + // parent. still, when it happens, skip activating it. + if (baseHiddenWindow != parent) { + nsCOMPtr parentWidget; + parent->GetMainWidget(getter_AddRefs(parentWidget)); + if (parentWidget) + parentWidget->PlaceBehind(eZPlacementTop, 0, true); + } + } + } +#endif + + mDOMWindow = nullptr; + if (mDocShell) { + nsCOMPtr shellAsWin(do_QueryInterface(mDocShell)); + shellAsWin->Destroy(); + mDocShell = nullptr; // this can cause reentrancy of this function + } + + // Remove our ref on the content shells + uint32_t count = mContentShells.Length(); + for (uint32_t i = 0; i < count; i++) { + nsContentShellInfo* shellInfo = mContentShells.ElementAt(i); + delete shellInfo; + } + mContentShells.Clear(); + mPrimaryContentShell = nullptr; + + if (mContentTreeOwner) { + mContentTreeOwner->XULWindow(nullptr); + NS_RELEASE(mContentTreeOwner); + } + if (mPrimaryContentTreeOwner) { + mPrimaryContentTreeOwner->XULWindow(nullptr); + NS_RELEASE(mPrimaryContentTreeOwner); + } + if (mChromeTreeOwner) { + mChromeTreeOwner->XULWindow(nullptr); + NS_RELEASE(mChromeTreeOwner); + } + if (mWindow) { + mWindow->SetWidgetListener(nullptr); // nsWebShellWindow hackery + mWindow->Destroy(); + mWindow = nullptr; + } + + if (!mIsHiddenWindow && mRegistered) { + /* Inform appstartup we've destroyed this window and it could + quit now if it wanted. This must happen at least after mDocShell + is destroyed, because onunload handlers fire then, and those being + script, anything could happen. A new window could open, even. + See bug 130719. */ + nsCOMPtr obssvc = services::GetObserverService(); + NS_ASSERTION(obssvc, "Couldn't get observer service?"); + + if (obssvc) + obssvc->NotifyObservers(nullptr, "xul-window-destroyed", nullptr); + } + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetDevicePixelsPerDesktopPixel(double *aScale) +{ + *aScale = mWindow ? mWindow->GetDesktopToDeviceScale().scale : 1.0; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetUnscaledDevicePixelsPerCSSPixel(double *aScale) +{ + *aScale = mWindow ? mWindow->GetDefaultScale().scale : 1.0; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetPositionDesktopPix(int32_t aX, int32_t aY) +{ + nsresult rv = mWindow->Move(aX, aY); + NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); + if (!mChromeLoaded) { + // If we're called before the chrome is loaded someone obviously wants this + // window at this position. We don't persist this one-time position. + mIgnoreXULPosition = true; + return NS_OK; + } + PersistentAttributesDirty(PAD_POSITION); + SavePersistentAttributes(); + return NS_OK; +} + +// The parameters here are device pixels; do the best we can to convert to +// desktop px, using the window's current scale factor (if available). +NS_IMETHODIMP nsXULWindow::SetPosition(int32_t aX, int32_t aY) +{ + // Don't reset the window's size mode here - platforms that don't want to move + // maximized windows should reset it in their respective Move implementation. + DesktopToLayoutDeviceScale currScale = mWindow->GetDesktopToDeviceScale(); + DesktopPoint pos = LayoutDeviceIntPoint(aX, aY) / currScale; + return SetPositionDesktopPix(pos.x, pos.y); +} + +NS_IMETHODIMP nsXULWindow::GetPosition(int32_t* aX, int32_t* aY) +{ + return GetPositionAndSize(aX, aY, nullptr, nullptr); +} + +NS_IMETHODIMP nsXULWindow::SetSize(int32_t aCX, int32_t aCY, bool aRepaint) +{ + /* any attempt to set the window's size or position overrides the window's + zoom state. this is important when these two states are competing while + the window is being opened. but it should probably just always be so. */ + mWindow->SetSizeMode(nsSizeMode_Normal); + + mIntrinsicallySized = false; + + DesktopToLayoutDeviceScale scale = mWindow->GetDesktopToDeviceScale(); + DesktopSize size = LayoutDeviceIntSize(aCX, aCY) / scale; + nsresult rv = mWindow->Resize(size.width, size.height, aRepaint); + NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); + if (!mChromeLoaded) { + // If we're called before the chrome is loaded someone obviously wants this + // window at this size & in the normal size mode (since it is the only mode + // in which setting dimensions makes sense). We don't persist this one-time + // size. + mIgnoreXULSize = true; + mIgnoreXULSizeMode = true; + return NS_OK; + } + PersistentAttributesDirty(PAD_SIZE); + SavePersistentAttributes(); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetSize(int32_t* aCX, int32_t* aCY) +{ + return GetPositionAndSize(nullptr, nullptr, aCX, aCY); +} + +NS_IMETHODIMP nsXULWindow::SetPositionAndSize(int32_t aX, int32_t aY, + int32_t aCX, int32_t aCY, uint32_t aFlags) +{ + /* any attempt to set the window's size or position overrides the window's + zoom state. this is important when these two states are competing while + the window is being opened. but it should probably just always be so. */ + mWindow->SetSizeMode(nsSizeMode_Normal); + + mIntrinsicallySized = false; + + DesktopToLayoutDeviceScale scale = mWindow->GetDesktopToDeviceScale(); + DesktopRect rect = LayoutDeviceIntRect(aX, aY, aCX, aCY) / scale; + nsresult rv = mWindow->Resize(rect.x, rect.y, rect.width, rect.height, + !!(aFlags & nsIBaseWindow::eRepaint)); + NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); + if (!mChromeLoaded) { + // If we're called before the chrome is loaded someone obviously wants this + // window at this size and position. We don't persist this one-time setting. + mIgnoreXULPosition = true; + mIgnoreXULSize = true; + mIgnoreXULSizeMode = true; + return NS_OK; + } + PersistentAttributesDirty(PAD_POSITION | PAD_SIZE); + SavePersistentAttributes(); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetPositionAndSize(int32_t* x, int32_t* y, int32_t* cx, + int32_t* cy) +{ + + if (!mWindow) + return NS_ERROR_FAILURE; + + LayoutDeviceIntRect rect = mWindow->GetScreenBounds(); + + if (x) + *x = rect.x; + if (y) + *y = rect.y; + if (cx) + *cx = rect.width; + if (cy) + *cy = rect.height; + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::Center(nsIXULWindow *aRelative, bool aScreen, bool aAlert) +{ + int32_t left, top, width, height, + ourWidth, ourHeight; + bool screenCoordinates = false, + windowCoordinates = false; + nsresult result; + + if (!mChromeLoaded) { + // note we lose the parameters. at time of writing, this isn't a problem. + mCenterAfterLoad = true; + return NS_OK; + } + + if (!aScreen && !aRelative) + return NS_ERROR_INVALID_ARG; + + nsCOMPtr screenmgr = do_GetService("@mozilla.org/gfx/screenmanager;1", &result); + if (NS_FAILED(result)) + return result; + + nsCOMPtr screen; + + if (aRelative) { + nsCOMPtr base(do_QueryInterface(aRelative, &result)); + if (base) { + // get window rect + result = base->GetPositionAndSize(&left, &top, &width, &height); + if (NS_SUCCEEDED(result)) { + double scale; + if (NS_SUCCEEDED(base->GetDevicePixelsPerDesktopPixel(&scale))) { + left = NSToIntRound(left / scale); + top = NSToIntRound(top / scale); + width = NSToIntRound(width / scale); + height = NSToIntRound(height / scale); + } + // if centering on screen, convert that to the corresponding screen + if (aScreen) + screenmgr->ScreenForRect(left, top, width, height, getter_AddRefs(screen)); + else + windowCoordinates = true; + } else { + // something's wrong with the reference window. + // fall back to the primary screen + aRelative = 0; + aScreen = true; + } + } + } + if (!aRelative) { + if (!mOpenerScreenRect.IsEmpty()) { + // FIXME - check if these are device or display pixels + screenmgr->ScreenForRect(mOpenerScreenRect.x, mOpenerScreenRect.y, + mOpenerScreenRect.width, mOpenerScreenRect.height, + getter_AddRefs(screen)); + } else { + screenmgr->GetPrimaryScreen(getter_AddRefs(screen)); + } + } + + if (aScreen && screen) { + screen->GetAvailRectDisplayPix(&left, &top, &width, &height); + screenCoordinates = true; + } + + if (screenCoordinates || windowCoordinates) { + NS_ASSERTION(mWindow, "what, no window?"); + double scale = mWindow->GetDesktopToDeviceScale().scale; + GetSize(&ourWidth, &ourHeight); + int32_t scaledWidth, scaledHeight; + scaledWidth = NSToIntRound(ourWidth / scale); + scaledHeight = NSToIntRound(ourHeight / scale); + left += (width - scaledWidth) / 2; + top += (height - scaledHeight) / (aAlert ? 3 : 2); + if (windowCoordinates) { + mWindow->ConstrainPosition(false, &left, &top); + } + SetPosition(left * scale, top * scale); + + // If moving the window caused it to change size, + // re-do the centering. + int32_t newWidth, newHeight; + GetSize(&newWidth, &newHeight); + if (newWidth != ourWidth || newHeight != ourHeight) { + return Center(aRelative, aScreen, aAlert); + } + return NS_OK; + } + + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP nsXULWindow::Repaint(bool aForce) +{ + //XXX First Check In + NS_ASSERTION(false, "Not Yet Implemented"); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetParentWidget(nsIWidget** aParentWidget) +{ + NS_ENSURE_ARG_POINTER(aParentWidget); + NS_ENSURE_STATE(mWindow); + + NS_IF_ADDREF(*aParentWidget = mWindow->GetParent()); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetParentWidget(nsIWidget* aParentWidget) +{ + //XXX First Check In + NS_ASSERTION(false, "Not Yet Implemented"); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetParentNativeWindow(nativeWindow* aParentNativeWindow) +{ + NS_ENSURE_ARG_POINTER(aParentNativeWindow); + + nsCOMPtr parentWidget; + NS_ENSURE_SUCCESS(GetParentWidget(getter_AddRefs(parentWidget)), NS_ERROR_FAILURE); + + if (parentWidget) { + *aParentNativeWindow = parentWidget->GetNativeData(NS_NATIVE_WIDGET); + } + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetParentNativeWindow(nativeWindow aParentNativeWindow) +{ + //XXX First Check In + NS_ASSERTION(false, "Not Yet Implemented"); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetNativeHandle(nsAString& aNativeHandle) +{ + nsCOMPtr mainWidget; + NS_ENSURE_SUCCESS(GetMainWidget(getter_AddRefs(mainWidget)), NS_ERROR_FAILURE); + + if (mainWidget) { + nativeWindow nativeWindowPtr = mainWidget->GetNativeData(NS_NATIVE_WINDOW); + /* the nativeWindow pointer is converted to and exposed as a string. This + is a more reliable way not to lose information (as opposed to JS + |Number| for instance) */ + aNativeHandle = NS_ConvertASCIItoUTF16(nsPrintfCString("0x%p", nativeWindowPtr)); + } + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetVisibility(bool* aVisibility) +{ + NS_ENSURE_ARG_POINTER(aVisibility); + + // Always claim to be visible for now. See bug + // https://bugzilla.mozilla.org/show_bug.cgi?id=306245. + + *aVisibility = true; + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetVisibility(bool aVisibility) +{ + if (!mChromeLoaded) { + mShowAfterLoad = aVisibility; + return NS_OK; + } + + if (mDebuting) { + return NS_OK; + } + mDebuting = true; // (Show / Focus is recursive) + + //XXXTAB Do we really need to show docshell and the window? Isn't + // the window good enough? + nsCOMPtr shellAsWin(do_QueryInterface(mDocShell)); + shellAsWin->SetVisibility(aVisibility); + // Store locally so it doesn't die on us. 'Show' can result in the window + // being closed with nsXULWindow::Destroy being called. That would set + // mWindow to null and posibly destroy the nsIWidget while its Show method + // is on the stack. We need to keep it alive until Show finishes. + nsCOMPtr window = mWindow; + window->Show(aVisibility); + + nsCOMPtr windowMediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (windowMediator) + windowMediator->UpdateWindowTimeStamp(static_cast(this)); + + // notify observers so that we can hide the splash screen if possible + nsCOMPtr obssvc = services::GetObserverService(); + NS_ASSERTION(obssvc, "Couldn't get observer service."); + if (obssvc) { + obssvc->NotifyObservers(nullptr, "xul-window-visible", nullptr); + } + + mDebuting = false; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetEnabled(bool *aEnabled) +{ + NS_ENSURE_ARG_POINTER(aEnabled); + + if (mWindow) { + *aEnabled = mWindow->IsEnabled(); + return NS_OK; + } + + *aEnabled = true; // better guess than most + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP nsXULWindow::SetEnabled(bool aEnable) +{ + if (mWindow) { + mWindow->Enable(aEnable); + return NS_OK; + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP nsXULWindow::GetMainWidget(nsIWidget** aMainWidget) +{ + NS_ENSURE_ARG_POINTER(aMainWidget); + + *aMainWidget = mWindow; + NS_IF_ADDREF(*aMainWidget); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetFocus() +{ + //XXX First Check In + NS_ASSERTION(false, "Not Yet Implemented"); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetTitle(char16_t** aTitle) +{ + NS_ENSURE_ARG_POINTER(aTitle); + + *aTitle = ToNewUnicode(mTitle); + if (!*aTitle) + return NS_ERROR_OUT_OF_MEMORY; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetTitle(const char16_t* aTitle) +{ + NS_ENSURE_STATE(mWindow); + mTitle.Assign(aTitle); + mTitle.StripChars("\n\r"); + NS_ENSURE_SUCCESS(mWindow->SetTitle(mTitle), NS_ERROR_FAILURE); + + // Tell the window mediator that a title has changed + nsCOMPtr windowMediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (!windowMediator) + return NS_OK; + + windowMediator->UpdateWindowTitle(static_cast(this), aTitle); + + return NS_OK; +} + + +//***************************************************************************** +// nsXULWindow: Helpers +//***************************************************************************** + +NS_IMETHODIMP nsXULWindow::EnsureChromeTreeOwner() +{ + if (mChromeTreeOwner) + return NS_OK; + + mChromeTreeOwner = new nsChromeTreeOwner(); + NS_ADDREF(mChromeTreeOwner); + mChromeTreeOwner->XULWindow(this); + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::EnsureContentTreeOwner() +{ + if (mContentTreeOwner) + return NS_OK; + + mContentTreeOwner = new nsContentTreeOwner(false); + NS_ADDREF(mContentTreeOwner); + mContentTreeOwner->XULWindow(this); + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::EnsurePrimaryContentTreeOwner() +{ + if (mPrimaryContentTreeOwner) + return NS_OK; + + mPrimaryContentTreeOwner = new nsContentTreeOwner(true); + NS_ADDREF(mPrimaryContentTreeOwner); + mPrimaryContentTreeOwner->XULWindow(this); + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::EnsurePrompter() +{ + if (mPrompter) + return NS_OK; + + nsCOMPtr ourWindow; + nsresult rv = GetWindowDOMWindow(getter_AddRefs(ourWindow)); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr wwatch = + do_GetService(NS_WINDOWWATCHER_CONTRACTID); + if (wwatch) + wwatch->GetNewPrompter(ourWindow, getter_AddRefs(mPrompter)); + } + return mPrompter ? NS_OK : NS_ERROR_FAILURE; +} + +NS_IMETHODIMP nsXULWindow::EnsureAuthPrompter() +{ + if (mAuthPrompter) + return NS_OK; + + nsCOMPtr ourWindow; + nsresult rv = GetWindowDOMWindow(getter_AddRefs(ourWindow)); + if (NS_SUCCEEDED(rv)) { + nsCOMPtr wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); + if (wwatch) + wwatch->GetNewAuthPrompter(ourWindow, getter_AddRefs(mAuthPrompter)); + } + return mAuthPrompter ? NS_OK : NS_ERROR_FAILURE; +} + +void nsXULWindow::OnChromeLoaded() +{ + nsresult rv = EnsureContentTreeOwner(); + + if (NS_SUCCEEDED(rv)) { + mChromeLoaded = true; + ApplyChromeFlags(); + SyncAttributesToWidget(); + + int32_t specWidth = -1, specHeight = -1; + bool gotSize = false; + + if (!mIgnoreXULSize) { + gotSize = LoadSizeFromXUL(specWidth, specHeight); + } + + bool positionSet = !mIgnoreXULPosition; + nsCOMPtr parentWindow(do_QueryReferent(mParentWindow)); +#if defined(XP_UNIX) && !defined(XP_MACOSX) + // don't override WM placement on unix for independent, top-level windows + // (however, we think the benefits of intelligent dependent window placement + // trump that override.) + if (!parentWindow) + positionSet = false; +#endif + if (positionSet) { + // We have to do this before sizing the window, because sizing depends + // on the resolution of the screen we're on. But positioning needs to + // know the size so that it can constrain to screen bounds.... as an + // initial guess here, we'll use the specified size (if any). + positionSet = LoadPositionFromXUL(specWidth, specHeight); + } + + if (gotSize) { + SetSpecifiedSize(specWidth, specHeight); + } + + if (mIntrinsicallySized) { + // (if LoadSizeFromXUL set the size, mIntrinsicallySized will be false) + nsCOMPtr cv; + mDocShell->GetContentViewer(getter_AddRefs(cv)); + if (cv) { + nsCOMPtr docShellAsItem = do_QueryInterface(mDocShell); + nsCOMPtr treeOwner; + docShellAsItem->GetTreeOwner(getter_AddRefs(treeOwner)); + if (treeOwner) { + // GetContentSize can fail, so initialise |width| and |height| to be + // on the safe side. + int32_t width = 0, height = 0; + if (NS_SUCCEEDED(cv->GetContentSize(&width, &height))) { + treeOwner->SizeShellTo(docShellAsItem, width, height); + // Update specified size for the final LoadPositionFromXUL call. + specWidth = width; + specHeight = height; + } + } + } + } + + // Now that we have set the window's final size, we can re-do its + // positioning so that it is properly constrained to the screen. + if (positionSet) { + LoadPositionFromXUL(specWidth, specHeight); + } + + LoadMiscPersistentAttributesFromXUL(); + + if (mCenterAfterLoad && !positionSet) { + Center(parentWindow, parentWindow ? false : true, false); + } + + if (mShowAfterLoad) { + SetVisibility(true); + // At this point the window may have been closed during Show(), so + // nsXULWindow::Destroy may already have been called. Take care! + } + } + mPersistentAttributesMask |= PAD_POSITION | PAD_SIZE | PAD_MISC; +} + +// If aSpecWidth and/or aSpecHeight are > 0, we will use these CSS px sizes +// to fit to the screen when staggering windows; if they're negative, +// we use the window's current size instead. +bool nsXULWindow::LoadPositionFromXUL(int32_t aSpecWidth, int32_t aSpecHeight) +{ + bool gotPosition = false; + + // if we're the hidden window, don't try to validate our size/position. We're + // special. + if (mIsHiddenWindow) + return false; + + nsCOMPtr windowElement = GetWindowDOMElement(); + NS_ENSURE_TRUE(windowElement, false); + + int32_t currX = 0; + int32_t currY = 0; + int32_t currWidth = 0; + int32_t currHeight = 0; + nsresult errorCode; + int32_t temp; + + GetPositionAndSize(&currX, &currY, &currWidth, &currHeight); + + // Convert to global display pixels for consistent window management across + // screens with diverse resolutions + double devToDesktopScale = 1.0 / mWindow->GetDesktopToDeviceScale().scale; + currX = NSToIntRound(currX * devToDesktopScale); + currY = NSToIntRound(currY * devToDesktopScale); + + // For size, use specified value if > 0, else current value + double devToCSSScale = 1.0 / mWindow->GetDefaultScale().scale; + int32_t cssWidth = + aSpecWidth > 0 ? aSpecWidth : NSToIntRound(currWidth * devToCSSScale); + int32_t cssHeight = + aSpecHeight > 0 ? aSpecHeight : NSToIntRound(currHeight * devToCSSScale); + + // Obtain the position information from the element. + int32_t specX = currX; + int32_t specY = currY; + nsAutoString posString; + + windowElement->GetAttribute(SCREENX_ATTRIBUTE, posString); + temp = posString.ToInteger(&errorCode); + if (NS_SUCCEEDED(errorCode)) { + specX = temp; + gotPosition = true; + } + windowElement->GetAttribute(SCREENY_ATTRIBUTE, posString); + temp = posString.ToInteger(&errorCode); + if (NS_SUCCEEDED(errorCode)) { + specY = temp; + gotPosition = true; + } + + if (gotPosition) { + // our position will be relative to our parent, if any + nsCOMPtr parent(do_QueryReferent(mParentWindow)); + if (parent) { + int32_t parentX, parentY; + if (NS_SUCCEEDED(parent->GetPosition(&parentX, &parentY))) { + double scale; + if (NS_SUCCEEDED(parent->GetDevicePixelsPerDesktopPixel(&scale))) { + parentX = NSToIntRound(parentX / scale); + parentY = NSToIntRound(parentY / scale); + } + specX += parentX; + specY += parentY; + } + } + else { + StaggerPosition(specX, specY, cssWidth, cssHeight); + } + } + mWindow->ConstrainPosition(false, &specX, &specY); + if (specX != currX || specY != currY) { + SetPositionDesktopPix(specX, specY); + } + + return gotPosition; +} + +bool +nsXULWindow::LoadSizeFromXUL(int32_t& aSpecWidth, int32_t& aSpecHeight) +{ + bool gotSize = false; + + // if we're the hidden window, don't try to validate our size/position. We're + // special. + if (mIsHiddenWindow) { + return false; + } + + nsCOMPtr windowElement = GetWindowDOMElement(); + NS_ENSURE_TRUE(windowElement, false); + + nsresult errorCode; + int32_t temp; + + // Obtain the sizing information from the element. + aSpecWidth = 100; + aSpecHeight = 100; + nsAutoString sizeString; + + windowElement->GetAttribute(WIDTH_ATTRIBUTE, sizeString); + temp = sizeString.ToInteger(&errorCode); + if (NS_SUCCEEDED(errorCode) && temp > 0) { + aSpecWidth = std::max(temp, 100); + gotSize = true; + } + windowElement->GetAttribute(HEIGHT_ATTRIBUTE, sizeString); + temp = sizeString.ToInteger(&errorCode); + if (NS_SUCCEEDED(errorCode) && temp > 0) { + aSpecHeight = std::max(temp, 100); + gotSize = true; + } + + return gotSize; +} + +void +nsXULWindow::SetSpecifiedSize(int32_t aSpecWidth, int32_t aSpecHeight) +{ + // constrain to screen size + nsCOMPtr domWindow; + GetWindowDOMWindow(getter_AddRefs(domWindow)); + if (domWindow) { + auto* window = nsPIDOMWindowOuter::From(domWindow); + nsCOMPtr screen = window->GetScreen(); + if (screen) { + int32_t screenWidth; + int32_t screenHeight; + screen->GetAvailWidth(&screenWidth); // CSS pixels + screen->GetAvailHeight(&screenHeight); + if (aSpecWidth > screenWidth) { + aSpecWidth = screenWidth; + } + if (aSpecHeight > screenHeight) { + aSpecHeight = screenHeight; + } + } + } + + NS_ASSERTION(mWindow, "we expected to have a window already"); + + int32_t currWidth = 0; + int32_t currHeight = 0; + GetSize(&currWidth, &currHeight); // returns device pixels + + // convert specified values to device pixels, and resize if needed + double cssToDevPx = mWindow ? mWindow->GetDefaultScale().scale : 1.0; + aSpecWidth = NSToIntRound(aSpecWidth * cssToDevPx); + aSpecHeight = NSToIntRound(aSpecHeight * cssToDevPx); + mIntrinsicallySized = false; + if (aSpecWidth != currWidth || aSpecHeight != currHeight) { + SetSize(aSpecWidth, aSpecHeight, false); + } +} + +/* Miscellaneous persistent attributes are attributes named in the + |persist| attribute, other than size and position. Those are special + because it's important to load those before one of the misc + attributes (sizemode) and they require extra processing. */ +bool nsXULWindow::LoadMiscPersistentAttributesFromXUL() +{ + bool gotState = false; + + /* There are no misc attributes of interest to the hidden window. + It's especially important not to try to validate that window's + size or position, because some platforms (Mac OS X) need to + make it visible and offscreen. */ + if (mIsHiddenWindow) + return false; + + nsCOMPtr windowElement = GetWindowDOMElement(); + NS_ENSURE_TRUE(windowElement, false); + + nsAutoString stateString; + + // sizemode + windowElement->GetAttribute(MODE_ATTRIBUTE, stateString); + nsSizeMode sizeMode = nsSizeMode_Normal; + /* ignore request to minimize, to not confuse novices + if (stateString.Equals(SIZEMODE_MINIMIZED)) + sizeMode = nsSizeMode_Minimized; + */ + if (!mIgnoreXULSizeMode && + (stateString.Equals(SIZEMODE_MAXIMIZED) || stateString.Equals(SIZEMODE_FULLSCREEN))) { + /* Honor request to maximize only if the window is sizable. + An unsizable, unmaximizable, yet maximized window confuses + Windows OS and is something of a travesty, anyway. */ + if (mChromeFlags & nsIWebBrowserChrome::CHROME_WINDOW_RESIZE) { + mIntrinsicallySized = false; + + if (stateString.Equals(SIZEMODE_MAXIMIZED)) + sizeMode = nsSizeMode_Maximized; + else + sizeMode = nsSizeMode_Fullscreen; + } + } + + // If we are told to ignore the size mode attribute update the + // document so the attribute and window are in sync. + if (mIgnoreXULSizeMode) { + nsAutoString sizeString; + if (sizeMode == nsSizeMode_Maximized) + sizeString.Assign(SIZEMODE_MAXIMIZED); + else if (sizeMode == nsSizeMode_Fullscreen) + sizeString.Assign(SIZEMODE_FULLSCREEN); + else if (sizeMode == nsSizeMode_Normal) + sizeString.Assign(SIZEMODE_NORMAL); + if (!sizeString.IsEmpty()) { + ErrorResult rv; + windowElement->SetAttribute(MODE_ATTRIBUTE, sizeString, rv); + } + } + + if (sizeMode == nsSizeMode_Fullscreen) { + nsCOMPtr ourWindow; + GetWindowDOMWindow(getter_AddRefs(ourWindow)); + auto* piWindow = nsPIDOMWindowOuter::From(ourWindow); + piWindow->SetFullScreen(true); + } else { + mWindow->SetSizeMode(sizeMode); + } + gotState = true; + + // zlevel + windowElement->GetAttribute(ZLEVEL_ATTRIBUTE, stateString); + if (!stateString.IsEmpty()) { + nsresult errorCode; + int32_t zLevel = stateString.ToInteger(&errorCode); + if (NS_SUCCEEDED(errorCode) && zLevel >= lowestZ && zLevel <= highestZ) + SetZLevel(zLevel); + } + + return gotState; +} + +/* Stagger windows of the same type so they don't appear on top of each other. + This code does have a scary double loop -- it'll keep passing through + the entire list of open windows until it finds a non-collision. Doesn't + seem to be a problem, but it deserves watching. + The aRequested{X,Y} parameters here are in desktop pixels; + the aSpec{Width,Height} parameters are CSS pixel dimensions. +*/ +void nsXULWindow::StaggerPosition(int32_t &aRequestedX, int32_t &aRequestedY, + int32_t aSpecWidth, int32_t aSpecHeight) +{ + // These "constants" will be converted from CSS to desktop pixels + // for the appropriate screen, assuming we find a screen to use... + // hence they're not actually declared const here. + int32_t kOffset = 22; + uint32_t kSlop = 4; + + bool keepTrying; + int bouncedX = 0, // bounced off vertical edge of screen + bouncedY = 0; // bounced off horizontal edge + + // look for any other windows of this type + nsCOMPtr wm(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (!wm) + return; + + nsCOMPtr windowElement = GetWindowDOMElement(); + if (!windowElement) + return; + + nsCOMPtr ourXULWindow(this); + + nsAutoString windowType; + windowElement->GetAttribute(WINDOWTYPE_ATTRIBUTE, windowType); + + int32_t screenTop = 0, // it's pointless to initialize these ... + screenRight = 0, // ... but to prevent oversalubrious and ... + screenBottom = 0, // ... underbright compilers from ... + screenLeft = 0; // ... issuing warnings. + bool gotScreen = false; + + { // fetch screen coordinates + nsCOMPtr screenMgr(do_GetService( + "@mozilla.org/gfx/screenmanager;1")); + if (screenMgr) { + nsCOMPtr ourScreen; + // the coordinates here are already display pixels + screenMgr->ScreenForRect(aRequestedX, aRequestedY, + aSpecWidth, aSpecHeight, + getter_AddRefs(ourScreen)); + if (ourScreen) { + int32_t screenWidth, screenHeight; + ourScreen->GetAvailRectDisplayPix(&screenLeft, &screenTop, + &screenWidth, &screenHeight); + screenBottom = screenTop + screenHeight; + screenRight = screenLeft + screenWidth; + // Get the screen's scaling factors and convert staggering constants + // from CSS px to desktop pixel units + double desktopToDeviceScale = 1.0, cssToDeviceScale = 1.0; + ourScreen->GetContentsScaleFactor(&desktopToDeviceScale); + ourScreen->GetDefaultCSSScaleFactor(&cssToDeviceScale); + double cssToDesktopFactor = cssToDeviceScale / desktopToDeviceScale; + kOffset = NSToIntRound(kOffset * cssToDesktopFactor); + kSlop = NSToIntRound(kSlop * cssToDesktopFactor); + // Convert dimensions from CSS to desktop pixels + aSpecWidth = NSToIntRound(aSpecWidth * cssToDesktopFactor); + aSpecHeight = NSToIntRound(aSpecHeight * cssToDesktopFactor); + gotScreen = true; + } + } + } + + // One full pass through all windows of this type, repeat until no collisions. + do { + keepTrying = false; + nsCOMPtr windowList; + wm->GetXULWindowEnumerator(windowType.get(), getter_AddRefs(windowList)); + + if (!windowList) + break; + + // One full pass through all windows of this type, offset and stop on collision. + do { + bool more; + windowList->HasMoreElements(&more); + if (!more) + break; + + nsCOMPtr supportsWindow; + windowList->GetNext(getter_AddRefs(supportsWindow)); + + nsCOMPtr listXULWindow(do_QueryInterface(supportsWindow)); + if (listXULWindow != ourXULWindow) { + int32_t listX, listY; + nsCOMPtr listBaseWindow(do_QueryInterface(supportsWindow)); + listBaseWindow->GetPosition(&listX, &listY); + double scale; + if (NS_SUCCEEDED(listBaseWindow->GetDevicePixelsPerDesktopPixel(&scale))) { + listX = NSToIntRound(listX / scale); + listY = NSToIntRound(listY / scale); + } + + if (Abs(listX - aRequestedX) <= kSlop && Abs(listY - aRequestedY) <= kSlop) { + // collision! offset and start over + if (bouncedX & 0x1) + aRequestedX -= kOffset; + else + aRequestedX += kOffset; + aRequestedY += kOffset; + + if (gotScreen) { + // if we're moving to the right and we need to bounce... + if (!(bouncedX & 0x1) && ((aRequestedX + aSpecWidth) > screenRight)) { + aRequestedX = screenRight - aSpecWidth; + ++bouncedX; + } + + // if we're moving to the left and we need to bounce... + if ((bouncedX & 0x1) && aRequestedX < screenLeft) { + aRequestedX = screenLeft; + ++bouncedX; + } + + // if we hit the bottom then bounce to the top + if (aRequestedY + aSpecHeight > screenBottom) { + aRequestedY = screenTop; + ++bouncedY; + } + } + + /* loop around again, + but it's time to give up once we've covered the screen. + there's a potential infinite loop with lots of windows. */ + keepTrying = bouncedX < 2 || bouncedY == 0; + break; + } + } + } while(1); + } while (keepTrying); +} + +void nsXULWindow::SyncAttributesToWidget() +{ + nsCOMPtr windowElement = GetWindowDOMElement(); + if (!windowElement) + return; + + nsAutoString attr; + + // "hidechrome" attribute + if (windowElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::hidechrome, + nsGkAtoms::_true, eCaseMatters)) { + mWindow->HideWindowChrome(true); + } + + // "chromemargin" attribute + nsIntMargin margins; + windowElement->GetAttribute(NS_LITERAL_STRING("chromemargin"), attr); + if (nsContentUtils::ParseIntMarginValue(attr, margins)) { + LayoutDeviceIntMargin tmp = LayoutDeviceIntMargin::FromUnknownMargin(margins); + mWindow->SetNonClientMargins(tmp); + } + + // "windowtype" attribute + windowElement->GetAttribute(WINDOWTYPE_ATTRIBUTE, attr); + if (!attr.IsEmpty()) { + mWindow->SetWindowClass(attr); + } + + // "id" attribute for icon + windowElement->GetAttribute(NS_LITERAL_STRING("id"), attr); + if (attr.IsEmpty()) { + attr.AssignLiteral("default"); + } + mWindow->SetIcon(attr); + + // "drawtitle" attribute + windowElement->GetAttribute(NS_LITERAL_STRING("drawtitle"), attr); + mWindow->SetDrawsTitle(attr.LowerCaseEqualsLiteral("true")); + + // "toggletoolbar" attribute + windowElement->GetAttribute(NS_LITERAL_STRING("toggletoolbar"), attr); + mWindow->SetShowsToolbarButton(attr.LowerCaseEqualsLiteral("true")); + + // "fullscreenbutton" attribute + windowElement->GetAttribute(NS_LITERAL_STRING("fullscreenbutton"), attr); + mWindow->SetShowsFullScreenButton(attr.LowerCaseEqualsLiteral("true")); + + // "macanimationtype" attribute + windowElement->GetAttribute(NS_LITERAL_STRING("macanimationtype"), attr); + if (attr.EqualsLiteral("document")) { + mWindow->SetWindowAnimationType(nsIWidget::eDocumentWindowAnimation); + } +} + +NS_IMETHODIMP nsXULWindow::SavePersistentAttributes() +{ + // can happen when the persistence timer fires at an inopportune time + // during window shutdown + if (!mDocShell) + return NS_ERROR_FAILURE; + + nsCOMPtr docShellElement = GetWindowDOMElement(); + if (!docShellElement) + return NS_ERROR_FAILURE; + + nsAutoString persistString; + docShellElement->GetAttribute(PERSIST_ATTRIBUTE, persistString); + if (persistString.IsEmpty()) { // quick check which sometimes helps + mPersistentAttributesDirty = 0; + return NS_OK; + } + + bool isFullscreen = false; + if (nsPIDOMWindowOuter* domWindow = mDocShell->GetWindow()) { + isFullscreen = domWindow->GetFullScreen(); + } + + // get our size, position and mode to persist + LayoutDeviceIntRect rect; + bool gotRestoredBounds = NS_SUCCEEDED(mWindow->GetRestoredBounds(rect)); + + // we use CSS pixels for size, but desktop pixels for position + CSSToLayoutDeviceScale sizeScale = mWindow->GetDefaultScale(); + DesktopToLayoutDeviceScale posScale = mWindow->GetDesktopToDeviceScale(); + + // make our position relative to our parent, if any + nsCOMPtr parent(do_QueryReferent(mParentWindow)); + if (parent && gotRestoredBounds) { + int32_t parentX, parentY; + if (NS_SUCCEEDED(parent->GetPosition(&parentX, &parentY))) { + rect.x -= parentX; + rect.y -= parentY; + } + } + + char sizeBuf[10]; + nsAutoString sizeString; + nsAutoString windowElementId; + nsCOMPtr ownerXULDoc; + + // fetch docShellElement's ID and XUL owner document + ownerXULDoc = do_QueryInterface(docShellElement->OwnerDoc()); + if (docShellElement->IsXULElement()) { + docShellElement->GetId(windowElementId); + } + + bool shouldPersist = !isFullscreen && ownerXULDoc; + ErrorResult rv; + // (only for size elements which are persisted) + if ((mPersistentAttributesDirty & PAD_POSITION) && gotRestoredBounds) { + if (persistString.Find("screenX") >= 0) { + SprintfLiteral(sizeBuf, "%d", NSToIntRound(rect.x / posScale.scale)); + sizeString.AssignWithConversion(sizeBuf); + docShellElement->SetAttribute(SCREENX_ATTRIBUTE, sizeString, rv); + if (shouldPersist) { + ownerXULDoc->Persist(windowElementId, SCREENX_ATTRIBUTE); + } + } + if (persistString.Find("screenY") >= 0) { + SprintfLiteral(sizeBuf, "%d", NSToIntRound(rect.y / posScale.scale)); + sizeString.AssignWithConversion(sizeBuf); + docShellElement->SetAttribute(SCREENY_ATTRIBUTE, sizeString, rv); + if (shouldPersist) { + ownerXULDoc->Persist(windowElementId, SCREENY_ATTRIBUTE); + } + } + } + + if ((mPersistentAttributesDirty & PAD_SIZE) && gotRestoredBounds) { + if (persistString.Find("width") >= 0) { + SprintfLiteral(sizeBuf, "%d", NSToIntRound(rect.width / sizeScale.scale)); + sizeString.AssignWithConversion(sizeBuf); + docShellElement->SetAttribute(WIDTH_ATTRIBUTE, sizeString, rv); + if (shouldPersist) { + ownerXULDoc->Persist(windowElementId, WIDTH_ATTRIBUTE); + } + } + if (persistString.Find("height") >= 0) { + SprintfLiteral(sizeBuf, "%d", NSToIntRound(rect.height / sizeScale.scale)); + sizeString.AssignWithConversion(sizeBuf); + docShellElement->SetAttribute(HEIGHT_ATTRIBUTE, sizeString, rv); + if (shouldPersist) { + ownerXULDoc->Persist(windowElementId, HEIGHT_ATTRIBUTE); + } + } + } + + if (mPersistentAttributesDirty & PAD_MISC) { + nsSizeMode sizeMode = mWindow->SizeMode(); + + if (sizeMode != nsSizeMode_Minimized) { + if (sizeMode == nsSizeMode_Maximized) + sizeString.Assign(SIZEMODE_MAXIMIZED); + else if (sizeMode == nsSizeMode_Fullscreen) + sizeString.Assign(SIZEMODE_FULLSCREEN); + else + sizeString.Assign(SIZEMODE_NORMAL); + docShellElement->SetAttribute(MODE_ATTRIBUTE, sizeString, rv); + if (shouldPersist && persistString.Find("sizemode") >= 0) { + ownerXULDoc->Persist(windowElementId, MODE_ATTRIBUTE); + } + } + if (persistString.Find("zlevel") >= 0) { + uint32_t zLevel; + nsCOMPtr mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (mediator) { + mediator->GetZLevel(this, &zLevel); + SprintfLiteral(sizeBuf, "%" PRIu32, zLevel); + sizeString.AssignWithConversion(sizeBuf); + docShellElement->SetAttribute(ZLEVEL_ATTRIBUTE, sizeString, rv); + if (shouldPersist) { + ownerXULDoc->Persist(windowElementId, ZLEVEL_ATTRIBUTE); + } + } + } + } + + mPersistentAttributesDirty = 0; + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetWindowDOMWindow(mozIDOMWindowProxy** aDOMWindow) +{ + NS_ENSURE_STATE(mDocShell); + + if (!mDOMWindow) + mDOMWindow = mDocShell->GetWindow(); + NS_ENSURE_TRUE(mDOMWindow, NS_ERROR_FAILURE); + + *aDOMWindow = mDOMWindow; + NS_ADDREF(*aDOMWindow); + return NS_OK; +} + +dom::Element* +nsXULWindow::GetWindowDOMElement() const +{ + NS_ENSURE_TRUE(mDocShell, nullptr); + + nsCOMPtr cv; + mDocShell->GetContentViewer(getter_AddRefs(cv)); + NS_ENSURE_TRUE(cv, nullptr); + + const nsIDocument* document = cv->GetDocument(); + NS_ENSURE_TRUE(document, nullptr); + + return document->GetRootElement(); +} + +nsresult nsXULWindow::ContentShellAdded(nsIDocShellTreeItem* aContentShell, + bool aPrimary, bool aTargetable, const nsAString& aID) +{ + nsContentShellInfo* shellInfo = nullptr; + + uint32_t i, count = mContentShells.Length(); + nsWeakPtr contentShellWeak = do_GetWeakReference(aContentShell); + for (i = 0; i < count; i++) { + nsContentShellInfo* info = mContentShells.ElementAt(i); + if (info->id.Equals(aID)) { + // We already exist. Do a replace. + info->child = contentShellWeak; + shellInfo = info; + } + else if (info->child == contentShellWeak) + info->child = nullptr; + } + + if (!shellInfo) { + shellInfo = new nsContentShellInfo(aID, contentShellWeak); + mContentShells.AppendElement(shellInfo); + } + + // Set the default content tree owner + if (aPrimary) { + NS_ENSURE_SUCCESS(EnsurePrimaryContentTreeOwner(), NS_ERROR_FAILURE); + aContentShell->SetTreeOwner(mPrimaryContentTreeOwner); + mPrimaryContentShell = aContentShell; + mPrimaryTabParent = nullptr; + } + else { + NS_ENSURE_SUCCESS(EnsureContentTreeOwner(), NS_ERROR_FAILURE); + aContentShell->SetTreeOwner(mContentTreeOwner); + if (mPrimaryContentShell == aContentShell) + mPrimaryContentShell = nullptr; + } + + if (aTargetable) { +#ifdef DEBUG + int32_t debugCount = mTargetableShells.Count(); + int32_t debugCounter; + for (debugCounter = debugCount - 1; debugCounter >= 0; --debugCounter) { + nsCOMPtr curItem = + do_QueryReferent(mTargetableShells[debugCounter]); + NS_ASSERTION(!SameCOMIdentity(curItem, aContentShell), + "Adding already existing item to mTargetableShells"); + } +#endif + + // put the new shell at the start of the targetable shells list if either + // it's the new primary shell or there is no existing primary shell (which + // means that chances are this one just stopped being primary). If we + // really cared, we could keep track of the "last no longer primary shell" + // explicitly, but it probably doesn't matter enough: the difference would + // only be felt in a situation where all shells were non-primary, which + // doesn't happen much. In a situation where there is one and only one + // primary shell, and in which shells get unmarked as primary before some + // other shell gets marked as primary, this effectively stores the list of + // targetable shells in "most recently primary first" order. + bool inserted; + if (aPrimary || !mPrimaryContentShell) { + inserted = mTargetableShells.InsertObjectAt(contentShellWeak, 0); + } else { + inserted = mTargetableShells.AppendObject(contentShellWeak); + } + NS_ENSURE_TRUE(inserted, NS_ERROR_OUT_OF_MEMORY); + } + + return NS_OK; +} + +nsresult nsXULWindow::ContentShellRemoved(nsIDocShellTreeItem* aContentShell) +{ + if (mPrimaryContentShell == aContentShell) { + mPrimaryContentShell = nullptr; + } + + int32_t i, count = mContentShells.Length(); + for (i = count - 1; i >= 0; --i) { + nsContentShellInfo* info = mContentShells.ElementAt(i); + nsCOMPtr curItem = do_QueryReferent(info->child); + if (!curItem || SameCOMIdentity(curItem, aContentShell)) { + mContentShells.RemoveElementAt(i); + delete info; + } + } + + count = mTargetableShells.Count(); + for (i = count - 1; i >= 0; --i) { + nsCOMPtr curItem = + do_QueryReferent(mTargetableShells[i]); + if (!curItem || SameCOMIdentity(curItem, aContentShell)) { + mTargetableShells.RemoveObjectAt(i); + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsXULWindow::GetPrimaryContentSize(int32_t* aWidth, + int32_t* aHeight) +{ + if (mPrimaryTabParent) { + return GetPrimaryTabParentSize(aWidth, aHeight); + } else if (mPrimaryContentShell) { + return GetPrimaryContentShellSize(aWidth, aHeight); + } + return NS_ERROR_UNEXPECTED; +} + +nsresult +nsXULWindow::GetPrimaryTabParentSize(int32_t* aWidth, + int32_t* aHeight) +{ + TabParent* tabParent = TabParent::GetFrom(mPrimaryTabParent); + // Need strong ref, since Client* can run script. + nsCOMPtr element = tabParent->GetOwnerElement(); + NS_ENSURE_STATE(element); + + *aWidth = element->ClientWidth(); + *aHeight = element->ClientHeight(); + return NS_OK; +} + +nsresult +nsXULWindow::GetPrimaryContentShellSize(int32_t* aWidth, + int32_t* aHeight) +{ + NS_ENSURE_STATE(mPrimaryContentShell); + + nsCOMPtr shellWindow(do_QueryInterface(mPrimaryContentShell)); + NS_ENSURE_STATE(shellWindow); + + int32_t devicePixelWidth, devicePixelHeight; + double shellScale = 1.0; + // We want to return CSS pixels. First, we get device pixels + // from the content area... + shellWindow->GetSize(&devicePixelWidth, &devicePixelHeight); + // And then get the device pixel scaling factor. Dividing device + // pixels by this scaling factor gives us CSS pixels. + shellWindow->GetUnscaledDevicePixelsPerCSSPixel(&shellScale); + *aWidth = NSToIntRound(devicePixelWidth / shellScale); + *aHeight = NSToIntRound(devicePixelHeight / shellScale); + return NS_OK; +} + +NS_IMETHODIMP +nsXULWindow::SetPrimaryContentSize(int32_t aWidth, + int32_t aHeight) +{ + if (mPrimaryTabParent) { + return SetPrimaryTabParentSize(aWidth, aHeight); + } else if (mPrimaryContentShell) { + return SizeShellTo(mPrimaryContentShell, aWidth, aHeight); + } + return NS_ERROR_UNEXPECTED; +} + +nsresult +nsXULWindow::SetPrimaryTabParentSize(int32_t aWidth, + int32_t aHeight) +{ + int32_t shellWidth, shellHeight; + GetPrimaryTabParentSize(&shellWidth, &shellHeight); + + double scale = 1.0; + GetUnscaledDevicePixelsPerCSSPixel(&scale); + + SizeShellToWithLimit(aWidth, aHeight, + shellWidth * scale, shellHeight * scale); + return NS_OK; +} + +nsresult +nsXULWindow::GetRootShellSize(int32_t* aWidth, + int32_t* aHeight) +{ + nsCOMPtr shellAsWin = do_QueryInterface(mDocShell); + NS_ENSURE_TRUE(shellAsWin, NS_ERROR_FAILURE); + return shellAsWin->GetSize(aWidth, aHeight); +} + +nsresult +nsXULWindow::SetRootShellSize(int32_t aWidth, + int32_t aHeight) +{ + nsCOMPtr docShellAsItem = do_QueryInterface(mDocShell); + return SizeShellTo(docShellAsItem, aWidth, aHeight); +} + +NS_IMETHODIMP nsXULWindow::SizeShellTo(nsIDocShellTreeItem* aShellItem, + int32_t aCX, int32_t aCY) +{ + // XXXTAB This is wrong, we should actually reflow based on the passed in + // shell. For now we are hacking and doing delta sizing. This is bad + // because it assumes all size we add will go to the shell which probably + // won't happen. + + nsCOMPtr shellAsWin(do_QueryInterface(aShellItem)); + NS_ENSURE_TRUE(shellAsWin, NS_ERROR_FAILURE); + + int32_t width = 0; + int32_t height = 0; + shellAsWin->GetSize(&width, &height); + + SizeShellToWithLimit(aCX, aCY, width, height); + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::ExitModalLoop(nsresult aStatus) +{ + if (mContinueModalLoop) + EnableParent(true); + mContinueModalLoop = false; + mModalStatus = aStatus; + return NS_OK; +} + +// top-level function to create a new window +NS_IMETHODIMP nsXULWindow::CreateNewWindow(int32_t aChromeFlags, + nsITabParent *aOpeningTab, + mozIDOMWindowProxy *aOpener, + nsIXULWindow **_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + + if (aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME) + return CreateNewChromeWindow(aChromeFlags, aOpeningTab, aOpener, _retval); + return CreateNewContentWindow(aChromeFlags, aOpeningTab, aOpener, _retval); +} + +NS_IMETHODIMP nsXULWindow::CreateNewChromeWindow(int32_t aChromeFlags, + nsITabParent *aOpeningTab, + mozIDOMWindowProxy *aOpener, + nsIXULWindow **_retval) +{ + nsCOMPtr appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID)); + NS_ENSURE_TRUE(appShell, NS_ERROR_FAILURE); + + // Just do a normal create of a window and return. + nsCOMPtr newWindow; + appShell->CreateTopLevelWindow(this, nullptr, aChromeFlags, + nsIAppShellService::SIZE_TO_CONTENT, + nsIAppShellService::SIZE_TO_CONTENT, + aOpeningTab, aOpener, + getter_AddRefs(newWindow)); + + NS_ENSURE_TRUE(newWindow, NS_ERROR_FAILURE); + + *_retval = newWindow; + NS_ADDREF(*_retval); + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::CreateNewContentWindow(int32_t aChromeFlags, + nsITabParent *aOpeningTab, + mozIDOMWindowProxy *aOpener, + nsIXULWindow **_retval) +{ + nsCOMPtr appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID)); + NS_ENSURE_TRUE(appShell, NS_ERROR_FAILURE); + + // We need to create a new top level window and then enter a nested + // loop. Eventually the new window will be told that it has loaded, + // at which time we know it is safe to spin out of the nested loop + // and allow the opening code to proceed. + + nsCOMPtr uri; + + nsAdoptingCString urlStr = Preferences::GetCString("browser.chromeURL"); + if (urlStr.IsEmpty()) { + urlStr.AssignLiteral("chrome://navigator/content/navigator.xul"); + } + + nsCOMPtr service(do_GetService(NS_IOSERVICE_CONTRACTID)); + if (service) { + service->NewURI(urlStr, nullptr, nullptr, getter_AddRefs(uri)); + } + NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE); + + // We need to create a chrome window to contain the content window we're about + // to pass back. The subject principal needs to be system while we're creating + // it to make things work right, so force a system caller. See bug 799348 + // comment 13 for a description of what happens when we don't. + nsCOMPtr newWindow; + { + AutoNoJSAPI nojsapi; + // We actually want this toplevel window which we are creating to have a + // null opener, as we will be creating the content xul:browser window inside + // of it, so we pass nullptr as our aOpener. + appShell->CreateTopLevelWindow(this, uri, + aChromeFlags, 615, 480, + aOpeningTab, nullptr, + getter_AddRefs(newWindow)); + NS_ENSURE_TRUE(newWindow, NS_ERROR_FAILURE); + } + + // Specify that we want the window to remain locked until the chrome has loaded. + nsXULWindow *xulWin = static_cast + (static_cast + (newWindow)); + + if (aOpener) { + nsCOMPtr docShell; + xulWin->GetDocShell(getter_AddRefs(docShell)); + MOZ_ASSERT(docShell); + nsCOMPtr chromeWindow = + do_QueryInterface(docShell->GetWindow()); + MOZ_ASSERT(chromeWindow); + + chromeWindow->SetOpenerForInitialContentBrowser(aOpener); + } + + xulWin->LockUntilChromeLoad(); + + { + AutoNoJSAPI nojsapi; + nsIThread *thread = NS_GetCurrentThread(); + while (xulWin->IsLocked()) { + if (!NS_ProcessNextEvent(thread)) + break; + } + } + + NS_ENSURE_STATE(xulWin->mPrimaryContentShell || xulWin->mPrimaryTabParent); + + *_retval = newWindow; + NS_ADDREF(*_retval); + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetHasPrimaryContent(bool* aResult) +{ + *aResult = mPrimaryTabParent || mPrimaryContentShell; + return NS_OK; +} + +void nsXULWindow::EnableParent(bool aEnable) +{ + nsCOMPtr parentWindow; + nsCOMPtr parentWidget; + + parentWindow = do_QueryReferent(mParentWindow); + if (parentWindow) + parentWindow->GetMainWidget(getter_AddRefs(parentWidget)); + if (parentWidget) + parentWidget->Enable(aEnable); +} + +// Constrain the window to its proper z-level +bool nsXULWindow::ConstrainToZLevel(bool aImmediate, + nsWindowZ *aPlacement, + nsIWidget *aReqBelow, + nsIWidget **aActualBelow) +{ +#if 0 + /* Do we have a parent window? This means our z-order is already constrained, + since we're a dependent window. Our window list isn't hierarchical, + so we can't properly calculate placement for such a window. + Should we just abort? */ + nsCOMPtr parentWindow = do_QueryReferent(mParentWindow); + if (parentWindow) + return false; +#endif + + nsCOMPtr mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (!mediator) + return false; + + bool altered; + uint32_t position, + newPosition, + zLevel; + nsIXULWindow *us = this; + + altered = false; + mediator->GetZLevel(this, &zLevel); + + // translate from WidgetGUIEvent to nsIWindowMediator constants + position = nsIWindowMediator::zLevelTop; + if (*aPlacement == nsWindowZBottom || zLevel == nsIXULWindow::lowestZ) + position = nsIWindowMediator::zLevelBottom; + else if (*aPlacement == nsWindowZRelative) + position = nsIWindowMediator::zLevelBelow; + + if (NS_SUCCEEDED(mediator->CalculateZPosition(us, position, aReqBelow, + &newPosition, aActualBelow, &altered))) { + /* If we were asked to move to the top but constrained to remain + below one of our other windows, first move all windows in that + window's layer and above to the top. This allows the user to + click a window which can't be topmost and still bring mozilla + to the foreground. */ + if (altered && + (position == nsIWindowMediator::zLevelTop || + (position == nsIWindowMediator::zLevelBelow && aReqBelow == 0))) + PlaceWindowLayersBehind(zLevel + 1, nsIXULWindow::highestZ, 0); + + if (*aPlacement != nsWindowZBottom && + position == nsIWindowMediator::zLevelBottom) + altered = true; + if (altered || aImmediate) { + if (newPosition == nsIWindowMediator::zLevelTop) + *aPlacement = nsWindowZTop; + else if (newPosition == nsIWindowMediator::zLevelBottom) + *aPlacement = nsWindowZBottom; + else + *aPlacement = nsWindowZRelative; + + if (aImmediate) { + nsCOMPtr ourBase = do_QueryObject(this); + if (ourBase) { + nsCOMPtr ourWidget; + ourBase->GetMainWidget(getter_AddRefs(ourWidget)); + ourWidget->PlaceBehind(*aPlacement == nsWindowZBottom ? + eZPlacementBottom : eZPlacementBelow, + *aActualBelow, false); + } + } + } + + /* CalculateZPosition can tell us to be below nothing, because it tries + not to change something it doesn't recognize. A request to verify + being below an unrecognized window, then, is treated as a request + to come to the top (below null) */ + nsCOMPtr windowAbove; + if (newPosition == nsIWindowMediator::zLevelBelow && *aActualBelow) { + windowAbove = (*aActualBelow)->GetWidgetListener()->GetXULWindow(); + } + + mediator->SetZPosition(us, newPosition, windowAbove); + } + + return altered; +} + +/* Re-z-position all windows in the layers from aLowLevel to aHighLevel, + inclusive, to be behind aBehind. aBehind of null means on top. + Note this method actually does nothing to our relative window positions. + (And therefore there's no need to inform WindowMediator we're moving + things, because we aren't.) This method is useful for, say, moving + a range of layers of our own windows relative to windows belonging to + external applications. +*/ +void nsXULWindow::PlaceWindowLayersBehind(uint32_t aLowLevel, + uint32_t aHighLevel, + nsIXULWindow *aBehind) +{ + // step through windows in z-order from top to bottommost window + + nsCOMPtr mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); + if (!mediator) + return; + + nsCOMPtr windowEnumerator; + mediator->GetZOrderXULWindowEnumerator(0, true, + getter_AddRefs(windowEnumerator)); + if (!windowEnumerator) + return; + + // each window will be moved behind previousHighWidget, itself + // a moving target. initialize it. + nsCOMPtr previousHighWidget; + if (aBehind) { + nsCOMPtr highBase(do_QueryInterface(aBehind)); + if (highBase) + highBase->GetMainWidget(getter_AddRefs(previousHighWidget)); + } + + // get next lower window + bool more; + while (windowEnumerator->HasMoreElements(&more), more) { + uint32_t nextZ; // z-level of nextWindow + nsCOMPtr nextWindow; + windowEnumerator->GetNext(getter_AddRefs(nextWindow)); + nsCOMPtr nextXULWindow(do_QueryInterface(nextWindow)); + nextXULWindow->GetZLevel(&nextZ); + if (nextZ < aLowLevel) + break; // we've processed all windows through aLowLevel + + // move it just below its next higher window + nsCOMPtr nextBase(do_QueryInterface(nextXULWindow)); + if (nextBase) { + nsCOMPtr nextWidget; + nextBase->GetMainWidget(getter_AddRefs(nextWidget)); + if (nextZ <= aHighLevel) + nextWidget->PlaceBehind(eZPlacementBelow, previousHighWidget, false); + previousHighWidget = nextWidget; + } + } +} + +void nsXULWindow::SetContentScrollbarVisibility(bool aVisible) +{ + nsCOMPtr contentWin(do_GetInterface(mPrimaryContentShell)); + if (!contentWin) { + return; + } + + nsContentUtils::SetScrollbarsVisibility(contentWin->GetDocShell(), aVisible); +} + +bool nsXULWindow::GetContentScrollbarVisibility() +{ + // This code already exists in dom/src/base/nsBarProp.cpp, but we + // can't safely get to that from here as this function is called + // while the DOM window is being set up, and we need the DOM window + // to get to that code. + nsCOMPtr scroller(do_QueryInterface(mPrimaryContentShell)); + + if (scroller) { + int32_t prefValue; + scroller->GetDefaultScrollbarPreferences( + nsIScrollable::ScrollOrientation_Y, &prefValue); + if (prefValue == nsIScrollable::Scrollbar_Never) // try the other way + scroller->GetDefaultScrollbarPreferences( + nsIScrollable::ScrollOrientation_X, &prefValue); + + if (prefValue == nsIScrollable::Scrollbar_Never) + return false; + } + + return true; +} + +// during spinup, attributes that haven't been loaded yet can't be dirty +void nsXULWindow::PersistentAttributesDirty(uint32_t aDirtyFlags) +{ + mPersistentAttributesDirty |= aDirtyFlags & mPersistentAttributesMask; +} + +NS_IMETHODIMP nsXULWindow::ApplyChromeFlags() +{ + nsCOMPtr window = GetWindowDOMElement(); + NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); + + if (mChromeLoaded) { + // The two calls in this block don't need to happen early because they + // don't cause a global restyle on the document. Not only that, but the + // scrollbar stuff needs a content area to toggle the scrollbars on anyway. + // So just don't do these until mChromeLoaded is true. + + // Scrollbars have their own special treatment. + SetContentScrollbarVisibility(mChromeFlags & + nsIWebBrowserChrome::CHROME_SCROLLBARS ? + true : false); + } + + /* the other flags are handled together. we have style rules + in navigator.css that trigger visibility based on + the 'chromehidden' attribute of the tag. */ + nsAutoString newvalue; + + if (! (mChromeFlags & nsIWebBrowserChrome::CHROME_MENUBAR)) + newvalue.AppendLiteral("menubar "); + + if (! (mChromeFlags & nsIWebBrowserChrome::CHROME_TOOLBAR)) + newvalue.AppendLiteral("toolbar "); + + if (! (mChromeFlags & nsIWebBrowserChrome::CHROME_LOCATIONBAR)) + newvalue.AppendLiteral("location "); + + if (! (mChromeFlags & nsIWebBrowserChrome::CHROME_PERSONAL_TOOLBAR)) + newvalue.AppendLiteral("directories "); + + if (! (mChromeFlags & nsIWebBrowserChrome::CHROME_STATUSBAR)) + newvalue.AppendLiteral("status "); + + if (! (mChromeFlags & nsIWebBrowserChrome::CHROME_EXTRA)) + newvalue.AppendLiteral("extrachrome "); + + // Note that if we're not actually changing the value this will be a no-op, + // so no need to compare to the old value. + ErrorResult rv; + window->SetAttribute(NS_LITERAL_STRING("chromehidden"), newvalue, rv); + + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::GetXULBrowserWindow(nsIXULBrowserWindow * *aXULBrowserWindow) +{ + NS_IF_ADDREF(*aXULBrowserWindow = mXULBrowserWindow); + return NS_OK; +} + +NS_IMETHODIMP nsXULWindow::SetXULBrowserWindow(nsIXULBrowserWindow * aXULBrowserWindow) +{ + mXULBrowserWindow = aXULBrowserWindow; + return NS_OK; +} + +void nsXULWindow::SizeShellToWithLimit(int32_t aDesiredWidth, + int32_t aDesiredHeight, + int32_t shellItemWidth, + int32_t shellItemHeight) +{ + int32_t widthDelta = aDesiredWidth - shellItemWidth; + int32_t heightDelta = aDesiredHeight - shellItemHeight; + + if (widthDelta || heightDelta) { + int32_t winWidth = 0; + int32_t winHeight = 0; + + GetSize(&winWidth, &winHeight); + // There's no point in trying to make the window smaller than the + // desired content area size --- that's not likely to work. This whole + // function assumes that the outer docshell is adding some constant + // "border" chrome to the content area. + winWidth = std::max(winWidth + widthDelta, aDesiredWidth); + winHeight = std::max(winHeight + heightDelta, aDesiredHeight); + SetSize(winWidth, winHeight, true); + } +} + +//***************************************************************************** +//*** nsContentShellInfo: Object Management +//***************************************************************************** + +nsContentShellInfo::nsContentShellInfo(const nsAString& aID, + nsIWeakReference* aContentShell) + : id(aID), + child(aContentShell) +{ + MOZ_COUNT_CTOR(nsContentShellInfo); +} + +nsContentShellInfo::~nsContentShellInfo() +{ + MOZ_COUNT_DTOR(nsContentShellInfo); + //XXX Set Tree Owner to null if the tree owner is nsXULWindow->mContentTreeOwner +} -- cgit v1.2.3