Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: 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
#include "nsViewManager.h"
#include "mozilla/MouseEvents.h"
#include "mozilla/PresShell.h"
#include "mozilla/PresShellInlines.h"
#include "mozilla/Preferences.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/StartupTimeline.h"
#include "mozilla/dom/Document.h"
#include "nsGfxCIID.h"
#include "nsView.h"
#include "nsCOMPtr.h"
#include "nsRegion.h"
#include "nsCOMArray.h"
#include "nsXULPopupManager.h"
#include "nsPresContext.h"
#include "nsRefreshDriver.h"
#include "nsContentUtils.h" // for nsAutoScriptBlocker
#include "nsLayoutUtils.h"
#include "gfxPlatform.h"
#include "WindowRenderer.h"
/**
XXX TODO XXX
DeCOMify newly private methods
Optimize view storage
*/
/**
A note about platform assumptions:
We assume that a widget is z-ordered on top of its parent.
We do NOT assume anything about the relative z-ordering of sibling widgets.
Even though we ask for a specific z-order, we don't assume that widget
z-ordering actually works.
*/
using namespace mozilla;
using namespace mozilla::layers;
#define NSCOORD_NONE INT32_MIN
#undef DEBUG_MOUSE_LOCATION
uint32_t nsViewManager::gLastUserEventTime = 0;
nsViewManager::nsViewManager()
: mPresShell(nullptr),
mDelayedResize(NSCOORD_NONE, NSCOORD_NONE),
mRootView(nullptr),
mRefreshDisableCount(0),
mPainting(false),
mRecursiveRefreshPending(false),
mHasPendingWidgetGeometryChanges(false) {}
nsViewManager::~nsViewManager() {
if (mRootView) {
// Destroy any remaining views
mRootView->Destroy();
mRootView = nullptr;
}
mRootViewManager = nullptr;
MOZ_RELEASE_ASSERT(!mPresShell,
"Releasing nsViewManager without having called Destroy on "
"the PresShell!");
}
// We don't hold a reference to the presentation context because it
// holds a reference to us.
nsresult nsViewManager::Init(nsDeviceContext* aContext) {
MOZ_ASSERT(nullptr != aContext, "null ptr");
if (nullptr == aContext) {
return NS_ERROR_NULL_POINTER;
}
if (nullptr != mContext) {
return NS_ERROR_ALREADY_INITIALIZED;
}
mContext = aContext;
return NS_OK;
}
nsView* nsViewManager::CreateView(const nsRect& aBounds, nsView* aParent,
ViewVisibility aVisibilityFlag) {
auto* v = new nsView(this, aVisibilityFlag);
v->SetParent(aParent);
v->SetPosition(aBounds.X(), aBounds.Y());
nsRect dim(0, 0, aBounds.Width(), aBounds.Height());
v->SetDimensions(dim, false);
return v;
}
void nsViewManager::SetRootView(nsView* aView) {
MOZ_ASSERT(!aView || aView->GetViewManager() == this,
"Unexpected viewmanager on root view");
// Do NOT destroy the current root view. It's the caller's responsibility
// to destroy it
mRootView = aView;
if (mRootView) {
nsView* parent = mRootView->GetParent();
if (parent) {
// Calling InsertChild on |parent| will InvalidateHierarchy() on us, so
// no need to set mRootViewManager ourselves here.
parent->InsertChild(mRootView, nullptr);
} else {
InvalidateHierarchy();
}
mRootView->SetZIndex(false, 0);
}
// Else don't touch mRootViewManager
}
void nsViewManager::GetWindowDimensions(nscoord* aWidth, nscoord* aHeight) {
if (nullptr != mRootView) {
if (mDelayedResize == nsSize(NSCOORD_NONE, NSCOORD_NONE)) {
nsRect dim = mRootView->GetDimensions();
*aWidth = dim.Width();
*aHeight = dim.Height();
} else {
*aWidth = mDelayedResize.width;
*aHeight = mDelayedResize.height;
}
} else {
*aWidth = 0;
*aHeight = 0;
}
}
void nsViewManager::DoSetWindowDimensions(nscoord aWidth, nscoord aHeight) {
nsRect oldDim = mRootView->GetDimensions();
nsRect newDim(0, 0, aWidth, aHeight);
// We care about resizes even when one dimension is already zero.
if (oldDim.IsEqualEdges(newDim)) {
return;
}
// Don't resize the widget. It is already being set elsewhere.
mRootView->SetDimensions(newDim, true, false);
if (RefPtr<PresShell> presShell = mPresShell) {
presShell->ResizeReflow(aWidth, aHeight);
}
}
bool nsViewManager::ShouldDelayResize() const {
MOZ_ASSERT(mRootView);
if (!mRootView->IsEffectivelyVisible() || !mPresShell ||
!mPresShell->IsVisible()) {
return true;
}
if (nsRefreshDriver* rd = mPresShell->GetRefreshDriver()) {
if (rd->IsResizeSuppressed()) {
return true;
}
}
return false;
}
void nsViewManager::SetWindowDimensions(nscoord aWidth, nscoord aHeight,
bool aDelayResize) {
if (mRootView) {
if (!ShouldDelayResize() && !aDelayResize) {
if (mDelayedResize != nsSize(NSCOORD_NONE, NSCOORD_NONE) &&
mDelayedResize != nsSize(aWidth, aHeight)) {
// We have a delayed resize; that now obsolete size may already have
// been flushed to the PresContext so we need to update the PresContext
// with the new size because if the new size is exactly the same as the
// root view's current size then DoSetWindowDimensions will not
mDelayedResize = nsSize(aWidth, aHeight);
FlushDelayedResize();
}
mDelayedResize.SizeTo(NSCOORD_NONE, NSCOORD_NONE);
DoSetWindowDimensions(aWidth, aHeight);
} else {
mDelayedResize.SizeTo(aWidth, aHeight);
if (mPresShell) {
mPresShell->SetNeedStyleFlush();
mPresShell->SetNeedLayoutFlush();
}
}
}
}
void nsViewManager::FlushDelayedResize() {
if (mDelayedResize != nsSize(NSCOORD_NONE, NSCOORD_NONE)) {
DoSetWindowDimensions(mDelayedResize.width, mDelayedResize.height);
mDelayedResize.SizeTo(NSCOORD_NONE, NSCOORD_NONE);
}
}
// Convert aIn from being relative to and in appunits of aFromView, to being
// relative to and in appunits of aToView.
static nsRegion ConvertRegionBetweenViews(const nsRegion& aIn,
nsView* aFromView, nsView* aToView) {
nsRegion out = aIn;
out.MoveBy(aFromView->GetOffsetTo(aToView));
out = out.ScaleToOtherAppUnitsRoundOut(
aFromView->GetViewManager()->AppUnitsPerDevPixel(),
aToView->GetViewManager()->AppUnitsPerDevPixel());
return out;
}
nsView* nsViewManager::GetDisplayRootFor(nsView* aView) {
nsView* displayRoot = aView;
for (;;) {
nsView* displayParent = displayRoot->GetParent();
if (!displayParent) return displayRoot;
if (displayRoot->GetFloating() && !displayParent->GetFloating())
return displayRoot;
// If we have a combobox dropdown popup within a panel popup, both the view
// for the dropdown popup and its parent will be floating, so we need to
// distinguish this situation. We do this by looking for a widget. Any view
// with a widget is a display root.
nsIWidget* widget = displayRoot->GetWidget();
if (widget && widget->GetWindowType() == widget::WindowType::Popup) {
NS_ASSERTION(displayRoot->GetFloating() && displayParent->GetFloating(),
"this should only happen with floating views that have "
"floating parents");
return displayRoot;
}
displayRoot = displayParent;
}
}
/**
aRegion is given in device coordinates!!
aContext may be null, in which case layers should be used for
rendering.
*/
void nsViewManager::Refresh(nsView* aView,
const LayoutDeviceIntRegion& aRegion) {
NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
if (mPresShell && mPresShell->IsNeverPainting()) {
return;
}
if (aRegion.IsEmpty()) {
return;
}
nsIWidget* widget = aView->GetWidget();
if (!widget) {
return;
}
NS_ASSERTION(!IsPainting(), "recursive painting not permitted");
if (IsPainting()) {
RootViewManager()->mRecursiveRefreshPending = true;
return;
}
{
nsAutoScriptBlocker scriptBlocker;
SetPainting(true);
NS_ASSERTION(GetDisplayRootFor(aView) == aView,
"Widgets that we paint must all be display roots");
if (RefPtr<PresShell> presShell = mPresShell) {
#ifdef MOZ_DUMP_PAINTING
if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
printf_stderr("--COMPOSITE-- %p\n", presShell.get());
}
#endif
WindowRenderer* renderer = widget->GetWindowRenderer();
if (!renderer->NeedsWidgetInvalidation()) {
renderer->FlushRendering(wr::RenderReasons::WIDGET);
} else {
presShell->SyncPaintFallback(aView);
}
#ifdef MOZ_DUMP_PAINTING
if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
printf_stderr("--ENDCOMPOSITE--\n");
}
#endif
mozilla::StartupTimeline::RecordOnce(
mozilla::StartupTimeline::FIRST_PAINT);
}
SetPainting(false);
}
if (RootViewManager()->mRecursiveRefreshPending) {
RootViewManager()->mRecursiveRefreshPending = false;
InvalidateAllViews();
}
}
void nsViewManager::ProcessPendingUpdatesForView(nsView* aView,
bool aFlushDirtyRegion) {
NS_ASSERTION(IsRootVM(), "Updates will be missed");
if (!aView) {
return;
}
RefPtr<PresShell> rootPresShell = mPresShell;
AutoTArray<nsCOMPtr<nsIWidget>, 1> widgets;
aView->GetViewManager()->ProcessPendingUpdatesRecurse(aView, widgets);
for (uint32_t i = 0; i < widgets.Length(); ++i) {
nsView* view = nsView::GetViewFor(widgets[i]);
if (view) {
if (view->mNeedsWindowPropertiesSync) {
view->mNeedsWindowPropertiesSync = false;
if (nsViewManager* vm = view->GetViewManager()) {
if (PresShell* presShell = vm->GetPresShell()) {
presShell->SyncWindowProperties(/* aSync */ true);
}
}
}
}
view = nsView::GetViewFor(widgets[i]);
if (view) {
view->ResetWidgetBounds(false, true);
}
}
if (rootPresShell->GetViewManager() != this) {
return; // presentation might have been torn down
}
if (aFlushDirtyRegion) {
nsAutoScriptBlocker scriptBlocker;
SetPainting(true);
for (uint32_t i = 0; i < widgets.Length(); ++i) {
nsIWidget* widget = widgets[i];
nsView* view = nsView::GetViewFor(widget);
if (view) {
RefPtr<nsViewManager> viewManager = view->GetViewManager();
viewManager->ProcessPendingUpdatesPaint(MOZ_KnownLive(widget));
}
}
SetPainting(false);
}
}
void nsViewManager::ProcessPendingUpdatesRecurse(
nsView* aView, AutoTArray<nsCOMPtr<nsIWidget>, 1>& aWidgets) {
if (mPresShell && mPresShell->IsNeverPainting()) {
return;
}
for (nsView* childView = aView->GetFirstChild(); childView;
childView = childView->GetNextSibling()) {
childView->GetViewManager()->ProcessPendingUpdatesRecurse(childView,
aWidgets);
}
nsIWidget* widget = aView->GetWidget();
if (widget) {
aWidgets.AppendElement(widget);
} else {
FlushDirtyRegionToWidget(aView);
}
}
void nsViewManager::ProcessPendingUpdatesPaint(nsIWidget* aWidget) {
if (aWidget->NeedsPaint()) {
// If an ancestor widget was hidden and then shown, we could
// have a delayed resize to handle.
for (RefPtr<nsViewManager> vm = this; vm;
vm = vm->mRootView->GetParent()
? vm->mRootView->GetParent()->GetViewManager()
: nullptr) {
if (vm->mDelayedResize != nsSize(NSCOORD_NONE, NSCOORD_NONE) &&
vm->mRootView->IsEffectivelyVisible() && vm->mPresShell &&
vm->mPresShell->IsVisible()) {
vm->FlushDelayedResize();
}
}
nsView* view = nsView::GetViewFor(aWidget);
if (!view) {
NS_ERROR("FlushDelayedResize destroyed the nsView?");
return;
}
nsIWidgetListener* previousListener =
aWidget->GetPreviouslyAttachedWidgetListener();
if (previousListener && previousListener != view &&
view->IsPrimaryFramePaintSuppressed()) {
return;
}
if (RefPtr<PresShell> presShell = mPresShell) {
#ifdef MOZ_DUMP_PAINTING
if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
printf_stderr(
"---- PAINT START ----PresShell(%p), nsView(%p), nsIWidget(%p)\n",
presShell.get(), view, aWidget);
}
#endif
presShell->PaintAndRequestComposite(view, PaintFlags::None);
view->SetForcedRepaint(false);
#ifdef MOZ_DUMP_PAINTING
if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
printf_stderr("---- PAINT END ----\n");
}
#endif
}
}
FlushDirtyRegionToWidget(nsView::GetViewFor(aWidget));
}
void nsViewManager::FlushDirtyRegionToWidget(nsView* aView) {
NS_ASSERTION(aView->GetViewManager() == this,
"FlushDirtyRegionToWidget called on view we don't own");
if (!aView->HasNonEmptyDirtyRegion()) {
return;
}
nsRegion& dirtyRegion = aView->GetDirtyRegion();
nsView* nearestViewWithWidget = aView;
while (!nearestViewWithWidget->HasWidget() &&
nearestViewWithWidget->GetParent()) {
nearestViewWithWidget = nearestViewWithWidget->GetParent();
}
nsRegion r =
ConvertRegionBetweenViews(dirtyRegion, aView, nearestViewWithWidget);
nsViewManager* widgetVM = nearestViewWithWidget->GetViewManager();
widgetVM->InvalidateWidgetArea(nearestViewWithWidget, r);
dirtyRegion.SetEmpty();
}
void nsViewManager::InvalidateView(nsView* aView) {
// Mark the entire view as damaged
InvalidateView(aView, aView->GetDimensions());
}
static void AddDirtyRegion(nsView* aView, const nsRegion& aDamagedRegion) {
nsRegion& dirtyRegion = aView->GetDirtyRegion();
dirtyRegion.Or(dirtyRegion, aDamagedRegion);
dirtyRegion.SimplifyOutward(8);
}
void nsViewManager::PostPendingUpdate() {
nsViewManager* rootVM = RootViewManager();
rootVM->mHasPendingWidgetGeometryChanges = true;
if (rootVM->mPresShell) {
rootVM->mPresShell->ScheduleViewManagerFlush();
}
}
/**
* @param aDamagedRegion this region, relative to aWidgetView, is invalidated in
* every widget child of aWidgetView, plus aWidgetView's own widget
*/
void nsViewManager::InvalidateWidgetArea(nsView* aWidgetView,
const nsRegion& aDamagedRegion) {
NS_ASSERTION(aWidgetView->GetViewManager() == this,
"InvalidateWidgetArea called on view we don't own");
nsIWidget* widget = aWidgetView->GetWidget();
#if 0
nsRect dbgBounds = aDamagedRegion.GetBounds();
printf("InvalidateWidgetArea view:%X (%d) widget:%X region: %d, %d, %d, %d\n",
aWidgetView, aWidgetView->IsAttachedToTopLevel(),
widget, dbgBounds.x, dbgBounds.y, dbgBounds.width, dbgBounds.height);
#endif
// If the widget is hidden, it don't cover nothing
if (widget && !widget->IsVisible()) {
return;
}
if (!widget) {
// The root view or a scrolling view might not have a widget
// (for example, during printing). We get here when we scroll
// during printing to show selected options in a listbox, for example.
return;
}
if (!aDamagedRegion.IsEmpty()) {
for (auto iter = aDamagedRegion.RectIter(); !iter.Done(); iter.Next()) {
LayoutDeviceIntRect bounds = ViewToWidget(aWidgetView, iter.Get());
widget->Invalidate(bounds);
}
}
}
static bool ShouldIgnoreInvalidation(nsViewManager* aVM) {
while (aVM) {
PresShell* presShell = aVM->GetPresShell();
if (!presShell || presShell->ShouldIgnoreInvalidation()) {
return true;
}
nsView* view = aVM->GetRootView()->GetParent();
aVM = view ? view->GetViewManager() : nullptr;
}
return false;
}
void nsViewManager::InvalidateView(nsView* aView, const nsRect& aRect) {
// If painting is suppressed in the presshell or an ancestor drop all
// invalidates, it will invalidate everything when it unsuppresses.
if (ShouldIgnoreInvalidation(this)) {
return;
}
InvalidateViewNoSuppression(aView, aRect);
}
void nsViewManager::InvalidateViewNoSuppression(nsView* aView,
const nsRect& aRect) {
MOZ_ASSERT(nullptr != aView, "null view");
NS_ASSERTION(aView->GetViewManager() == this,
"InvalidateViewNoSuppression called on view we don't own");
nsRect damagedRect(aRect);
if (damagedRect.IsEmpty()) {
return;
}
nsView* displayRoot = GetDisplayRootFor(aView);
nsViewManager* displayRootVM = displayRoot->GetViewManager();
// Propagate the update to the displayRoot, since iframes, for example,
// can overlap each other and be translucent. So we have to possibly
// invalidate our rect in each of the widgets we have lying about.
damagedRect.MoveBy(aView->GetOffsetTo(displayRoot));
int32_t rootAPD = displayRootVM->AppUnitsPerDevPixel();
int32_t APD = AppUnitsPerDevPixel();
damagedRect = damagedRect.ScaleToOtherAppUnitsRoundOut(APD, rootAPD);
// accumulate this rectangle in the view's dirty region, so we can
// process it later.
AddDirtyRegion(displayRoot, nsRegion(damagedRect));
}
void nsViewManager::InvalidateAllViews() {
if (RootViewManager() != this) {
return RootViewManager()->InvalidateAllViews();
}
InvalidateViews(mRootView);
}
void nsViewManager::InvalidateViews(nsView* aView) {
// Invalidate this view.
InvalidateView(aView);
// Invalidate all children as well.
nsView* childView = aView->GetFirstChild();
while (nullptr != childView) {
childView->GetViewManager()->InvalidateViews(childView);
childView = childView->GetNextSibling();
}
}
void nsViewManager::WillPaintWindow(nsIWidget* aWidget) {
if (aWidget) {
nsView* view = nsView::GetViewFor(aWidget);
WindowRenderer* renderer = aWidget->GetWindowRenderer();
if (view &&
(view->ForcedRepaint() || !renderer->NeedsWidgetInvalidation())) {
ProcessPendingUpdates();
// Re-get the view pointer here since the ProcessPendingUpdates might have
// destroyed it during CallWillPaintOnObservers.
view = nsView::GetViewFor(aWidget);
if (view) {
view->SetForcedRepaint(false);
}
}
}
}
bool nsViewManager::PaintWindow(nsIWidget* aWidget,
const LayoutDeviceIntRegion& aRegion) {
if (!aWidget || !mContext) return false;
NS_ASSERTION(
IsPaintingAllowed(),
"shouldn't be receiving paint events while painting is disallowed!");
// Get the view pointer here since NS_WILL_PAINT might have
nsView* view = nsView::GetViewFor(aWidget);
if (view && !aRegion.IsEmpty()) {
Refresh(view, aRegion);
}
return true;
}
void nsViewManager::DidPaintWindow() {
if (RefPtr<PresShell> presShell = mPresShell) {
presShell->DidPaintWindow();
}
}
void nsViewManager::DispatchEvent(WidgetGUIEvent* aEvent, nsView* aView,
nsEventStatus* aStatus) {
AUTO_PROFILER_LABEL("nsViewManager::DispatchEvent", OTHER);
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
if ((mouseEvent &&
// Ignore mouse events that we synthesize.
mouseEvent->mReason == WidgetMouseEvent::eReal &&
// Ignore mouse exit and enter (we'll get moves if the user
// is really moving the mouse) since we get them when we
// create and destroy widgets.
mouseEvent->mMessage != eMouseExitFromWidget &&
mouseEvent->mMessage != eMouseEnterIntoWidget) ||
aEvent->HasKeyEventMessage() || aEvent->HasIMEEventMessage()) {
gLastUserEventTime = PR_IntervalToMicroseconds(PR_IntervalNow());
}
// Find the view whose coordinates system we're in.
nsView* view = aView;
bool dispatchUsingCoordinates = aEvent->IsUsingCoordinates();
if (dispatchUsingCoordinates) {
// Will dispatch using coordinates. Pretty bogus but it's consistent
// with what presshell does.
view = GetDisplayRootFor(view);
}
// If the view has no frame, look for a view that does.
nsIFrame* frame = view->GetFrame();
if (!frame && (dispatchUsingCoordinates || aEvent->HasKeyEventMessage() ||
aEvent->IsIMERelatedEvent())) {
while (view && !view->GetFrame()) {
view = view->GetParent();
}
if (view) {
frame = view->GetFrame();
}
}
if (nullptr != frame) {
// Hold a refcount to the presshell. The continued existence of the
// presshell will delay deletion of this view hierarchy should the event
// want to cause its destruction in, say, some JavaScript event handler.
if (RefPtr<PresShell> presShell = view->GetViewManager()->GetPresShell()) {
presShell->HandleEvent(frame, aEvent, false, aStatus);
return;
}
}
*aStatus = nsEventStatus_eIgnore;
}
// Recursively reparent widgets if necessary
void nsViewManager::ReparentChildWidgets(nsView* aView, nsIWidget* aNewWidget) {
MOZ_ASSERT(aNewWidget, "null widget");
if (aView->HasWidget()) {
// Check to see if the parent widget is the
// same as the new parent. If not then reparent
// the widget, otherwise there is nothing more
// to do for the view and its descendants
nsIWidget* widget = aView->GetWidget();
nsIWidget* parentWidget = widget->GetParent();
if (parentWidget) {
// Child widget
if (parentWidget != aNewWidget) {
widget->SetParent(aNewWidget);
}
} else {
// Toplevel widget (popup, dialog, etc)
widget->ReparentNativeWidget(aNewWidget);
}
return;
}
// Need to check each of the views children to see
// if they have a widget and reparent it.
for (nsView* kid = aView->GetFirstChild(); kid; kid = kid->GetNextSibling()) {
ReparentChildWidgets(kid, aNewWidget);
}
}
// Reparent a view and its descendant views widgets if necessary
void nsViewManager::ReparentWidgets(nsView* aView, nsView* aParent) {
MOZ_ASSERT(aParent, "Must have a parent");
MOZ_ASSERT(aView, "Must have a view");
// Quickly determine whether the view has pre-existing children or a
// widget. In most cases the view will not have any pre-existing
// children when this is called. Only in the case
// where a view has been reparented by removing it from
// a reinserting it into a new location in the view hierarchy do we
// have to consider reparenting the existing widgets for the view and
// it's descendants.
if (aView->HasWidget() || aView->GetFirstChild()) {
nsIWidget* parentWidget = aParent->GetNearestWidget(nullptr);
if (parentWidget) {
ReparentChildWidgets(aView, parentWidget);
return;
}
NS_WARNING("Can not find a widget for the parent view");
}
}
void nsViewManager::InsertChild(nsView* aParent, nsView* aChild,
nsView* aSibling, bool aAfter) {
MOZ_ASSERT(nullptr != aParent, "null ptr");
MOZ_ASSERT(nullptr != aChild, "null ptr");
NS_ASSERTION(aSibling == nullptr || aSibling->GetParent() == aParent,
"tried to insert view with invalid sibling");
NS_ASSERTION(!IsViewInserted(aChild),
"tried to insert an already-inserted view");
if ((nullptr != aParent) && (nullptr != aChild)) {
// if aAfter is set, we will insert the child after 'prev' (i.e. after 'kid'
// in document order, otherwise after 'kid' (i.e. before 'kid' in document
// order).
if (nullptr == aSibling) {
if (aAfter) {
// insert at end of document order, i.e., before first view
// this is the common case, by far
aParent->InsertChild(aChild, nullptr);
ReparentWidgets(aChild, aParent);
} else {
// insert at beginning of document order, i.e., after last view
nsView* kid = aParent->GetFirstChild();
nsView* prev = nullptr;
while (kid) {
prev = kid;
kid = kid->GetNextSibling();
}
// prev is last view or null if there are no children
aParent->InsertChild(aChild, prev);
ReparentWidgets(aChild, aParent);
}
} else {
nsView* kid = aParent->GetFirstChild();
nsView* prev = nullptr;
while (kid && aSibling != kid) {
// get the next sibling view
prev = kid;
kid = kid->GetNextSibling();
}
NS_ASSERTION(kid != nullptr, "couldn't find sibling in child list");
if (aAfter) {
// insert after 'kid' in document order, i.e. before in view order
aParent->InsertChild(aChild, prev);
ReparentWidgets(aChild, aParent);
} else {
// insert before 'kid' in document order, i.e. after in view order
aParent->InsertChild(aChild, kid);
ReparentWidgets(aChild, aParent);
}
}
// if the parent view is marked as "floating", make the newly added view
// float as well.
if (aParent->GetFloating()) aChild->SetFloating(true);
}
}
void nsViewManager::RemoveChild(nsView* aChild) {
NS_ASSERTION(aChild, "aChild must not be null");
nsView* parent = aChild->GetParent();
if (nullptr != parent) {
NS_ASSERTION(
aChild->GetViewManager() == this || parent->GetViewManager() == this,
"wrong view manager");
parent->RemoveChild(aChild);
}
}
void nsViewManager::MoveViewTo(nsView* aView, nscoord aX, nscoord aY) {
NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
aView->SetPosition(aX, aY);
}
void nsViewManager::ResizeView(nsView* aView, const nsRect& aRect,
bool aRepaintExposedAreaOnly) {
NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
nsRect oldDimensions = aView->GetDimensions();
if (!oldDimensions.IsEqualEdges(aRect)) {
aView->SetDimensions(aRect, true);
}
// Note that if layout resizes the view and the view has a custom clip
// region set, then we expect layout to update the clip region too. Thus
// in the case where mClipRect has been optimized away to just be a null
// pointer, and this resize is implicitly changing the clip rect, it's OK
// because layout will change it back again if necessary.
}
void nsViewManager::SetViewFloating(nsView* aView, bool aFloating) {
NS_ASSERTION(!(nullptr == aView), "no view");
aView->SetFloating(aFloating);
}
void nsViewManager::SetViewVisibility(nsView* aView, ViewVisibility aVisible) {
NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
if (aVisible != aView->GetVisibility()) {
aView->SetVisibility(aVisible);
}
}
bool nsViewManager::IsViewInserted(nsView* aView) {
if (mRootView == aView) {
return true;
}
if (aView->GetParent() == nullptr) {
return false;
}
nsView* view = aView->GetParent()->GetFirstChild();
while (view != nullptr) {
if (view == aView) {
return true;
}
view = view->GetNextSibling();
}
return false;
}
void nsViewManager::SetViewZIndex(nsView* aView, bool aAutoZIndex,
int32_t aZIndex) {
NS_ASSERTION((aView != nullptr), "no view");
// don't allow the root view's z-index to be changed. It should always be
// zero. This could be removed and replaced with a style rule, or just removed
// altogether, with interesting consequences
if (aView == mRootView) {
return;
}
if (aAutoZIndex) {
aZIndex = 0;
}
aView->SetZIndex(aAutoZIndex, aZIndex);
}
nsViewManager* nsViewManager::IncrementDisableRefreshCount() {
if (!IsRootVM()) {
return RootViewManager()->IncrementDisableRefreshCount();
}
++mRefreshDisableCount;
return this;
}
void nsViewManager::DecrementDisableRefreshCount() {
NS_ASSERTION(IsRootVM(), "Should only be called on root");
--mRefreshDisableCount;
NS_ASSERTION(mRefreshDisableCount >= 0, "Invalid refresh disable count!");
}
nsIWidget* nsViewManager::GetRootWidget() const {
if (!mRootView) {
return nullptr;
}
if (mRootView->HasWidget()) {
return mRootView->GetWidget();
}
if (mRootView->GetParent()) {
return mRootView->GetParent()->GetViewManager()->GetRootWidget();
}
return nullptr;
}
LayoutDeviceIntRect nsViewManager::ViewToWidget(nsView* aView,
const nsRect& aRect) const {
NS_ASSERTION(aView->GetViewManager() == this, "wrong view manager");
// account for the view's origin not lining up with the widget's
nsRect rect = aRect + aView->ViewToWidgetOffset();
// finally, convert to device coordinates.
return LayoutDeviceIntRect::FromUnknownRect(
rect.ToOutsidePixels(AppUnitsPerDevPixel()));
}
void nsViewManager::IsPainting(bool& aIsPainting) {
aIsPainting = IsPainting();
}
void nsViewManager::ProcessPendingUpdates() {
if (!IsRootVM()) {
RefPtr<nsViewManager> rootViewManager = RootViewManager();
rootViewManager->ProcessPendingUpdates();
return;
}
// Flush things like reflows by calling WillPaint on observer presShells.
if (mPresShell) {
mPresShell->GetPresContext()->RefreshDriver()->RevokeViewManagerFlush();
RefPtr<nsViewManager> strongThis(this);
CallWillPaintOnObservers();
ProcessPendingUpdatesForView(mRootView, true);
if (mPresShell) {
if (nsPresContext* pc = mPresShell->GetPresContext()) {
pc->RefreshDriver()->ClearHasScheduleFlush();
}
}
}
}
void nsViewManager::UpdateWidgetGeometry() {
if (!IsRootVM()) {
RefPtr<nsViewManager> rootViewManager = RootViewManager();
rootViewManager->UpdateWidgetGeometry();
return;
}
if (mHasPendingWidgetGeometryChanges) {
mHasPendingWidgetGeometryChanges = false;
ProcessPendingUpdatesForView(mRootView, false);
}
}
/* static */ void nsViewManager::CollectVMsForWillPaint(
nsView* aView, nsViewManager* aParentVM,
nsTArray<RefPtr<nsViewManager>>& aVMs) {
nsViewManager* vm = aView->GetViewManager();
if (vm != aParentVM) {
aVMs.AppendElement(vm);
}
for (nsView* child = aView->GetFirstChild(); child;
child = child->GetNextSibling()) {
CollectVMsForWillPaint(child, vm, aVMs);
}
}
void nsViewManager::CallWillPaintOnObservers() {
MOZ_ASSERT(IsRootVM(), "Must be root VM for this to be called!");
if (!mRootView) {
return;
}
AutoTArray<RefPtr<nsViewManager>, 2> VMs;
CollectVMsForWillPaint(mRootView, nullptr, VMs);
for (const auto& vm : VMs) {
if (vm->GetRootView() && vm->GetRootView()->IsEffectivelyVisible()) {
if (RefPtr<PresShell> presShell = vm->GetPresShell()) {
presShell->WillPaint();
}
}
}
}
void nsViewManager::GetLastUserEventTime(uint32_t& aTime) {
aTime = gLastUserEventTime;
}
void nsViewManager::InvalidateHierarchy() {
if (mRootView) {
mRootViewManager = nullptr;
nsView* parent = mRootView->GetParent();
if (parent) {
mRootViewManager = parent->GetViewManager()->RootViewManager();
NS_ASSERTION(mRootViewManager != this,
"Root view had a parent, but it has the same view manager");
}
// else, we are implicitly our own root view manager.
}
}