Merge branch 'main' of https://github.com/secondlife/viewer into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/llrender/llfontbitmapcache.cpp
#	indra/llrender/llfontbitmapcache.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llrender/llfontfreetype.h
#	indra/llrender/llfontgl.cpp
#	indra/llrender/llfontgl.h
#	indra/llui/llbutton.h
#	indra/llui/llfloater.cpp
#	indra/llui/llfloater.h
#	indra/llui/llfolderviewitem.cpp
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/llscrollcontainer.cpp
#	indra/llui/llscrollingpanellist.cpp
#	indra/llui/llscrollingpanellist.h
#	indra/llui/llscrolllistctrl.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltexteditor.h
#	indra/llui/lluictrl.cpp
#	indra/llui/llview.cpp
#	indra/llui/llview.h
#	indra/newview/llchicletbar.h
#	indra/newview/llconversationlog.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterimsessiontab.h
#	indra/newview/llfloateruipreview.cpp
#	indra/newview/llnavigationbar.h
#	indra/newview/llpaneltopinfobar.h
#	indra/newview/llpathfindingpathtool.h
#	indra/newview/lltextureview.cpp
#	indra/newview/lltoolbrush.h
#	indra/newview/lltoolcomp.h
#	indra/newview/lltooldraganddrop.h
#	indra/newview/lltoolface.h
#	indra/newview/lltoolfocus.h
#	indra/newview/lltoolindividual.h
#	indra/newview/lltoolobjpicker.h
#	indra/newview/lltoolpie.h
#	indra/newview/lltoolpipette.h
#	indra/newview/lltoolselectland.h
#	indra/newview/llviewermediafocus.h
#	indra/newview/llviewerparcelmediaautoplay.h
#	indra/newview/llviewerwindow.cpp
#	indra/newview/llvoicechannel.h
#	indra/newview/llvoicevivox.h
#	indra/newview/llworldmapview.cpp

1 files changed, 146 insertions, 36 deletions

diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index 87ab9d0b19..3ba56c6da1 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -182,6 +182,7 @@ LLFloater::Params::Params()
 	save_visibility("save_visibility", false),
 	can_dock("can_dock", false),
 	show_title("show_title", true),
+	auto_close("auto_close", false),
 	positioning("positioning", LLFloaterEnums::POSITIONING_RELATIVE),
 	header_height("header_height", 0),
 	legacy_header_height("legacy_header_height", 0),
@@ -254,6 +255,7 @@ LLFloater::LLFloater(const LLSD& key, const LLFloater::Params& p)
 	mCanClose(p.can_close),
 	mDragOnLeft(p.can_drag_on_left),
 	mResizable(p.can_resize),
+	mAutoClose(p.auto_close),
 	mPositioning(p.positioning),
 	mMinWidth(p.min_width),
 	mMinHeight(p.min_height),
@@ -504,6 +506,7 @@ void LLFloater::enableResizeCtrls(bool enable, bool width, bool height)
 
 void LLFloater::destroy()
 {
+	gFloaterView->onDestroyFloater(this);
 	// LLFloaterReg should be synchronized with "dead" floater to avoid returning dead instance before
 	// it was deleted via LLMortician::updateClass(). See EXT-8458.
 	LLFloaterReg::removeInstance(mInstanceName, mKey);
@@ -681,7 +684,7 @@ void LLFloater::openFloater(const LLSD& key)
 	if (getHost() != NULL)
 	{
 		getHost()->setMinimized(false);
-		getHost()->setVisibleAndFrontmost(mAutoFocus);
+		getHost()->setVisibleAndFrontmost(mAutoFocus && !getIsChrome());
 		getHost()->showFloater(this);
 	}
 	else
@@ -693,7 +696,7 @@ void LLFloater::openFloater(const LLSD& key)
 		}
 		applyControlsAndPosition(floater_to_stack);
 		setMinimized(false);
-		setVisibleAndFrontmost(mAutoFocus);
+		setVisibleAndFrontmost(mAutoFocus && !getIsChrome());
 	}
 
 	mOpenSignal(this, key);
@@ -829,6 +832,24 @@ void LLFloater::reshape(S32 width, S32 height, bool called_from_parent)
 	LLPanel::reshape(width, height, called_from_parent);
 }
 
+// virtual
+void LLFloater::translate(S32 x, S32 y)
+{
+    LLView::translate(x, y);
+
+    if (!mTranslateWithDependents || mDependents.empty())
+        return;
+
+    for (const LLHandle<LLFloater>& handle : mDependents)
+    {
+        LLFloater* floater = handle.get();
+        if (floater && floater->getSnapTarget() == getHandle())
+        {
+            floater->LLView::translate(x, y);
+        }
+    }
+}
+
 void LLFloater::releaseFocus()
 {
 	LLUI::getInstance()->removePopup(this);
@@ -1117,9 +1138,9 @@ bool LLFloater::canSnapTo(const LLView* other_view)
 
 	if (other_view != getParent())
 	{
-		const LLFloater* other_floaterp = dynamic_cast<const LLFloater*>(other_view);		
-		if (other_floaterp 
-			&& other_floaterp->getSnapTarget() == getHandle() 
+		const LLFloater* other_floaterp = dynamic_cast<const LLFloater*>(other_view);
+		if (other_floaterp
+			&& other_floaterp->getSnapTarget() == getHandle()
 			&& mDependents.find(other_floaterp->getHandle()) != mDependents.end())
 		{
 			// this is a dependent that is already snapped to us, so don't snap back to it
@@ -1509,30 +1530,40 @@ bool LLFloater::isFrontmost()
 				&& floater_view->getFrontmost() == this);
 }
 
-void LLFloater::addDependentFloater(LLFloater* floaterp, bool reposition)
+void LLFloater::addDependentFloater(LLFloater* floaterp, bool reposition, bool resize)
 {
 	mDependents.insert(floaterp->getHandle());
 	floaterp->mDependeeHandle = getHandle();
 
 	if (reposition)
 	{
-		floaterp->setRect(gFloaterView->findNeighboringPosition(this, floaterp));
+		LLRect rect = gFloaterView->findNeighboringPosition(this, floaterp);
+		if (resize)
+		{
+			const LLRect& base = getRect();
+			if (rect.mTop == base.mTop)
+				rect.mBottom = base.mBottom;
+			else if (rect.mLeft == base.mLeft)
+				rect.mRight = base.mRight;
+			floaterp->reshape(rect.getWidth(), rect.getHeight(), false);
+		}
+		floaterp->setRect(rect);
 		floaterp->setSnapTarget(getHandle());
 	}
 	gFloaterView->adjustToFitScreen(floaterp, false, true);
 	if (floaterp->isFrontmost())
 	{
 		// make sure to bring self and sibling floaters to front
-		gFloaterView->bringToFront(floaterp);
+		gFloaterView->bringToFront(floaterp, floaterp->getAutoFocus() && !getIsChrome());
 	}
 }
 
-void LLFloater::addDependentFloater(LLHandle<LLFloater> dependent, bool reposition)
+void LLFloater::addDependentFloater(LLHandle<LLFloater> dependent, bool reposition, bool resize)
 {
 	LLFloater* dependent_floaterp = dependent.get();
 	if(dependent_floaterp)
 	{
-		addDependentFloater(dependent_floaterp, reposition);
+		addDependentFloater(dependent_floaterp, reposition, resize);
 	}
 }
 
@@ -1542,6 +1573,44 @@ void LLFloater::removeDependentFloater(LLFloater* floaterp)
 	floaterp->mDependeeHandle = LLHandle<LLFloater>();
 }
 
+void LLFloater::fitWithDependentsOnScreen(const LLRect& left, const LLRect& bottom, const LLRect& right, const LLRect& constraint, S32 min_overlap_pixels)
+{
+    LLRect total_rect = getRect();
+
+    for (const LLHandle<LLFloater>& handle : mDependents)
+    {
+        LLFloater* floater = handle.get();
+        if (floater && floater->getSnapTarget() == getHandle())
+        {
+            total_rect.unionWith(floater->getRect());
+        }
+    }
+
+	S32 delta_left = left.notEmpty() ? left.mRight - total_rect.mRight : 0;
+	S32 delta_bottom = bottom.notEmpty() ? bottom.mTop - total_rect.mTop : 0;
+	S32 delta_right = right.notEmpty() ? right.mLeft - total_rect.mLeft : 0;
+
+	// move floater with dependings fully onscreen
+    mTranslateWithDependents = true;
+    if (translateRectIntoRect(total_rect, constraint, min_overlap_pixels))
+    {
+        clearSnapTarget();
+    }
+    else if (delta_left > 0 && total_rect.mTop < left.mTop && total_rect.mBottom > left.mBottom)
+    {
+        translate(delta_left, 0);
+    }
+    else if (delta_bottom > 0 && total_rect.mLeft > bottom.mLeft && total_rect.mRight < bottom.mRight)
+    {
+        translate(0, delta_bottom);
+    }
+    else if (delta_right < 0 && total_rect.mTop < right.mTop    && total_rect.mBottom > right.mBottom)
+    {
+        translate(delta_right, 0);
+    }
+    mTranslateWithDependents = false;
+}
+
 bool LLFloater::offerClickToButton(S32 x, S32 y, MASK mask, EFloaterButton index)
 {
 	if( mButtonsEnabled[index] )
@@ -1630,6 +1699,7 @@ bool LLFloater::handleDoubleClick(S32 x, S32 y, MASK mask)
 	return was_minimized || LLPanel::handleDoubleClick(x, y, mask);
 }
 
+// virtual
 void LLFloater::bringToFront( S32 x, S32 y )
 {
 	if (getVisible() && pointInView(x, y))
@@ -1644,12 +1714,20 @@ void LLFloater::bringToFront( S32 x, S32 y )
 			LLFloaterView* parent = dynamic_cast<LLFloaterView*>( getParent() );
 			if (parent)
 			{
-				parent->bringToFront( this );
+				parent->bringToFront(this, !getIsChrome());
 			}
 		}
 	}
 }
 
+// virtual
+void LLFloater::goneFromFront()
+{
+    if (mAutoClose)
+    {
+        closeFloater();
+    }
+}
 
 // virtual
 void LLFloater::setVisibleAndFrontmost(bool take_focus,const LLSD& key)
@@ -2488,13 +2566,18 @@ void LLFloaterView::bringToFront(LLFloater* child, bool give_focus, bool restore
 
 	if (mFrontChild == child)
 	{
-		if (give_focus && !gFocusMgr.childHasKeyboardFocus(child))
+		if (give_focus && child->canFocusStealFrontmost() && !gFocusMgr.childHasKeyboardFocus(child))
 		{
 			child->setFocus(true);
 		}
 		return;
 	}
 
+	if (mFrontChild)
+	{
+		mFrontChild->goneFromFront();
+	}
+
 	mFrontChild = child;
 
 	// *TODO: make this respect floater's mAutoFocus value, instead of
@@ -2852,10 +2935,17 @@ void LLFloaterView::adjustToFitScreen(LLFloater* floater, bool allow_partial_out
 		// floater is hosted elsewhere, so ignore
 		return;
 	}
+
+	if (floater->getDependee() &&
+		floater->getDependee() == floater->getSnapTarget().get())
+	{
+		// floater depends on other and snaps to it, so ignore
+		return;
+	}
+
 	LLRect::tCoordType screen_width = getSnapRect().getWidth();
 	LLRect::tCoordType screen_height = getSnapRect().getHeight();
 
-	
 	// only automatically resize non-minimized, resizable floaters
 	if( floater->isResizable() && !floater->isMinimized() )
 	{
@@ -2897,29 +2987,10 @@ void LLFloaterView::adjustToFitScreen(LLFloater* floater, bool allow_partial_out
 		}
 	}
 
-	const LLRect& floater_rect = floater->getRect();
-
-	S32 delta_left = mToolbarLeftRect.notEmpty() ? mToolbarLeftRect.mRight - floater_rect.mRight : 0;
-	S32 delta_bottom = mToolbarBottomRect.notEmpty() ? mToolbarBottomRect.mTop - floater_rect.mTop : 0;
-	S32 delta_right = mToolbarRightRect.notEmpty() ? mToolbarRightRect.mLeft - floater_rect.mLeft : 0;
+    const LLRect& constraint = snap_in_toolbars ? getSnapRect() : gFloaterView->getRect();
+    S32 min_overlap_pixels = allow_partial_outside ? FLOATER_MIN_VISIBLE_PIXELS : S32_MAX;
 
-	// move window fully onscreen
-	if (floater->translateIntoRect( snap_in_toolbars ? getSnapRect() : gFloaterView->getRect(), allow_partial_outside ? FLOATER_MIN_VISIBLE_PIXELS : S32_MAX ))
-	{
-		floater->clearSnapTarget();
-	}
-	else if (delta_left > 0 && floater_rect.mTop < mToolbarLeftRect.mTop && floater_rect.mBottom > mToolbarLeftRect.mBottom)
-	{
-		floater->translate(delta_left, 0);
-	}
-	else if (delta_bottom > 0 && floater_rect.mLeft > mToolbarBottomRect.mLeft && floater_rect.mRight < mToolbarBottomRect.mRight)
-	{
-		floater->translate(0, delta_bottom);
-	}
-	else if (delta_right < 0 && floater_rect.mTop < mToolbarRightRect.mTop	&& floater_rect.mBottom > mToolbarRightRect.mBottom)
-	{
-		floater->translate(delta_right, 0);
-	}
+	floater->fitWithDependentsOnScreen(mToolbarLeftRect, mToolbarBottomRect, mToolbarRightRect, constraint, min_overlap_pixels);
 }
 
 void LLFloaterView::draw()
@@ -3006,6 +3077,9 @@ LLFloater *LLFloaterView::getBackmost() const
 
 void LLFloaterView::syncFloaterTabOrder()
 {
+	if (mFrontChild && !mFrontChild->isDead() && mFrontChild->getIsChrome())
+		return;
+
 	// look for a visible modal dialog, starting from first
 	LLModalDialog* modal_dialog = NULL;
 	for ( child_list_const_iter_t child_it = getChildList()->begin(); child_it != getChildList()->end(); ++child_it)
@@ -3041,7 +3115,34 @@ void LLFloaterView::syncFloaterTabOrder()
 			LLFloater* floaterp = dynamic_cast<LLFloater*>(*child_it);
 			if (gFocusMgr.childHasKeyboardFocus(floaterp))
 			{
-				bringToFront(floaterp, false);
+                if (mFrontChild != floaterp)
+                {
+                    // Grab a list of the top floaters that want to stay on top of the focused floater
+					std::list<LLFloater*> listTop;
+					if (mFrontChild && !mFrontChild->canFocusStealFrontmost())
+                    {
+                        for (LLView* childp : *getChildList())
+                        {
+							LLFloater* child_floaterp = static_cast<LLFloater*>(childp);
+                            if (child_floaterp->canFocusStealFrontmost())
+                                break;
+							listTop.push_back(child_floaterp);
+                        }
+                    }
+
+                    bringToFront(floaterp, false);
+
+                    // Restore top floaters
+					if (!listTop.empty())
+					{
+						for (LLView* childp : listTop)
+						{
+							sendChildToFront(childp);
+						}
+						mFrontChild = listTop.back();
+					}
+                }
+
 				break;
 			}
 		}
@@ -3134,6 +3235,14 @@ void LLFloaterView::setToolbarRect(LLToolBarEnums::EToolBarLocation tb, const LL
 	}
 }
 
+void LLFloaterView::onDestroyFloater(LLFloater* floater)
+{
+    if (mFrontChild == floater)
+    {
+        mFrontChild = nullptr;
+    }
+}
+
 void LLFloater::setInstanceName(const std::string& name)
 {
 	if (name != mInstanceName)
@@ -3226,6 +3335,7 @@ void LLFloater::initFromParams(const LLFloater::Params& p)
 	mDefaultRelativeY = p.rel_y;
 
 	mPositioning = p.positioning;
+	mAutoClose = p.auto_close;
 
 	mSaveRect = p.save_rect;
 	if (p.save_visibility)