Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 609 insertions, 609 deletions

diff --git a/indra/llui/llfloaterreg.cpp b/indra/llui/llfloaterreg.cpp
index 1c3efaa9cf..fad1155d90 100644
--- a/indra/llui/llfloaterreg.cpp
+++ b/indra/llui/llfloaterreg.cpp
@@ -1,609 +1,609 @@
-/** 
- * @file llfloaterreg.cpp
- * @brief LLFloaterReg Floater Registration Class
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llfloaterreg.h"
-
-//#include "llagent.h" 
-#include "llfloater.h"
-#include "llmultifloater.h"
-#include "llfloaterreglistener.h"
-#include "lluiusage.h"
-
-//*******************************************************
-
-//static
-LLFloaterReg::instance_list_t LLFloaterReg::sNullInstanceList;
-LLFloaterReg::instance_map_t LLFloaterReg::sInstanceMap;
-LLFloaterReg::build_map_t LLFloaterReg::sBuildMap;
-std::map<std::string,std::string> LLFloaterReg::sGroupMap;
-bool LLFloaterReg::sBlockShowFloaters = false;
-std::set<std::string> LLFloaterReg::sAlwaysShowableList;
-
-static LLFloaterRegListener sFloaterRegListener;
-
-//*******************************************************
-
-//static
-void LLFloaterReg::add(const std::string& name, const std::string& filename, const LLFloaterBuildFunc& func, const std::string& groupname)
-{
-	sBuildMap[name].mFunc = func;
-	sBuildMap[name].mFile = filename;
-	sGroupMap[name] = groupname.empty() ? name : groupname;
-	sGroupMap[groupname] = groupname; // for referencing directly by group name
-}
-
-//static
-bool LLFloaterReg::isRegistered(const std::string& name)
-{
-    return sBuildMap.find(name) != sBuildMap.end();
-}
-
-//static
-LLFloater* LLFloaterReg::getLastFloaterInGroup(const std::string& name)
-{
-	const std::string& groupname = sGroupMap[name];
-	if (!groupname.empty())
-	{
-		instance_list_t& list = sInstanceMap[groupname];
-		if (!list.empty())
-		{
-			for (instance_list_t::reverse_iterator iter = list.rbegin(); iter != list.rend(); ++iter)
-			{
-				LLFloater* inst = *iter;
-
-				if (inst->getVisible() && !inst->isMinimized())
-				{
-					return inst;
-				}
-			}
-		}
-	}
-	return NULL;
-}
-
-LLFloater* LLFloaterReg::getLastFloaterCascading()
-{
-	LLRect candidate_rect;
-	candidate_rect.mTop = 100000;
-	LLFloater* candidate_floater = NULL;
-
-	std::map<std::string,std::string>::const_iterator it = sGroupMap.begin(), it_end = sGroupMap.end();
-	for( ; it != it_end; ++it)
-	{
-		const std::string& group_name = it->second;
-
-		instance_list_t& instances = sInstanceMap[group_name];
-
-		for (instance_list_t::const_iterator iter = instances.begin(); iter != instances.end(); ++iter)
-		{
-			LLFloater* inst = *iter;
-
-			if (inst->getVisible() 
-				&& (inst->isPositioning(LLFloaterEnums::POSITIONING_CASCADING)
-					|| inst->isPositioning(LLFloaterEnums::POSITIONING_CASCADE_GROUP)))
-			{
-				if (candidate_rect.mTop > inst->getRect().mTop)
-				{
-					candidate_floater = inst;
-					candidate_rect = inst->getRect();
-				}
-			}
-		}
-	}
-
-	return candidate_floater;
-}
-
-//static
-LLFloater* LLFloaterReg::findInstance(const std::string& name, const LLSD& key)
-{
-	LLFloater* res = NULL;
-	const std::string& groupname = sGroupMap[name];
-	if (!groupname.empty())
-	{
-		instance_list_t& list = sInstanceMap[groupname];
-		for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)
-		{
-			LLFloater* inst = *iter;
-			if (inst->matchesKey(key))
-			{
-				res = inst;
-				break;
-			}
-		}
-	}
-	return res;
-}
-
-//static
-LLFloater* LLFloaterReg::getInstance(const std::string& name, const LLSD& key) 
-{
-	LLFloater* res = findInstance(name, key);
-	if (!res)
-	{
-		const LLFloaterBuildFunc& build_func = sBuildMap[name].mFunc;
-		const std::string& xui_file = sBuildMap[name].mFile;
-		if (build_func)
-		{
-			const std::string& groupname = sGroupMap[name];
-			if (!groupname.empty())
-			{
-				instance_list_t& list = sInstanceMap[groupname];
-
-				res = build_func(key);
-				if (!res)
-				{
-					LL_WARNS() << "Failed to build floater type: '" << name << "'." << LL_ENDL;
-					return NULL;
-				}
-				bool success = res->buildFromFile(xui_file);
-				if (!success)
-				{
-					LL_WARNS() << "Failed to build floater type: '" << name << "'." << LL_ENDL;
-					return NULL;
-				}
-
-				// Note: key should eventually be a non optional LLFloater arg; for now, set mKey to be safe
-				if (res->mKey.isUndefined()) 
-				{
-					res->mKey = key;
-				}
-				res->setInstanceName(name);
-
-				LLFloater *last_floater = (list.empty() ? NULL : list.back());
-
-				res->applyControlsAndPosition(last_floater);
-
-				gFloaterView->adjustToFitScreen(res, false);
-
-				list.push_back(res);
-			}
-		}
-		if (!res)
-		{
-			LL_WARNS() << "Floater type: '" << name << "' not registered." << LL_ENDL;
-		}
-	}
-	return res;
-}
-
-//static
-LLFloater* LLFloaterReg::removeInstance(const std::string& name, const LLSD& key)
-{
-	LLFloater* res = NULL;
-	const std::string& groupname = sGroupMap[name];
-	if (!groupname.empty())
-	{
-		instance_list_t& list = sInstanceMap[groupname];
-		for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)
-		{
-			LLFloater* inst = *iter;
-			if (inst->matchesKey(key))
-			{
-				res = inst;
-				list.erase(iter);
-				break;
-			}
-		}
-	}
-	return res;
-}
-
-//static
-// returns true if the instance existed
-bool LLFloaterReg::destroyInstance(const std::string& name, const LLSD& key)
-{
-	LLFloater* inst = removeInstance(name, key);
-	if (inst)
-	{
-		delete inst;
-		return true;
-	}
-	else
-	{
-		return false;
-	}
-}
-
-// Iterators
-//static
-LLFloaterReg::const_instance_list_t& LLFloaterReg::getFloaterList(const std::string& name)
-{
-	instance_map_t::iterator iter = sInstanceMap.find(name);
-	if (iter != sInstanceMap.end())
-	{
-		return iter->second;
-	}
-	else
-	{
-		return sNullInstanceList;
-	}
-}
-
-// Visibility Management
-
-//static
-LLFloater* LLFloaterReg::showInstance(const std::string& name, const LLSD& key, bool focus) 
-{
-	if( sBlockShowFloaters
-			// see EXT-7090
-			&& sAlwaysShowableList.find(name) == sAlwaysShowableList.end())
-		return 0;//
-	LLFloater* instance = getInstance(name, key); 
-	if (instance) 
-	{
-		instance->openFloater(key);
-		if (focus)
-			instance->setFocus(true);
-	}
-	return instance;
-}
-
-//static
-// returns true if the instance exists
-bool LLFloaterReg::hideInstance(const std::string& name, const LLSD& key) 
-{ 
-	LLFloater* instance = findInstance(name, key); 
-	if (instance)
-	{
-		instance->closeHostedFloater();
-	}
-	return (instance != NULL);
-}
-
-//static
-// returns true if the instance is visible when completed
-bool LLFloaterReg::toggleInstance(const std::string& name, const LLSD& key)
-{
-	LLFloater* instance = findInstance(name, key); 
-	if (instance && instance->isShown())
-	{
-		instance->closeHostedFloater();
-		return false;
-	}
-
-	instance = showInstance(name, key, true);
-
-	return instance != nullptr;
-}
-
-//static
-// returns true if the instance exists and is visible (doesnt matter minimized or not)
-bool LLFloaterReg::instanceVisible(const std::string& name, const LLSD& key)
-{
-	LLFloater* instance = findInstance(name, key); 
-	return LLFloater::isVisible(instance);
-}
-
-//static
-void LLFloaterReg::showInitialVisibleInstances() 
-{
-	// Iterate through alll registered instance names and show any with a save visible state
-	for (build_map_t::iterator iter = sBuildMap.begin(); iter != sBuildMap.end(); ++iter)
-	{
-		const std::string& name = iter->first;
-		std::string controlname = getVisibilityControlName(name);
-		if (LLFloater::getControlGroup()->controlExists(controlname))
-		{
-			bool isvis = LLFloater::getControlGroup()->getBOOL(controlname);
-			if (isvis)
-			{
-				showInstance(name, LLSD()); // keyed floaters shouldn't set save_vis to true
-			}
-		}
-	}
-}
-
-//static
-void LLFloaterReg::hideVisibleInstances(const std::set<std::string>& exceptions)
-{
-	// Iterate through alll active instances and hide them
-	for (instance_map_t::iterator iter = sInstanceMap.begin(); iter != sInstanceMap.end(); ++iter)
-	{
-		const std::string& name = iter->first;
-		if (exceptions.find(name) != exceptions.end())
-			continue;
-		instance_list_t& list = iter->second;
-		for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)
-		{
-			LLFloater* floater = *iter;
-			floater->pushVisible(false);
-		}
-	}
-}
-
-//static
-void LLFloaterReg::restoreVisibleInstances()
-{
-	// Iterate through all active instances and restore visibility
-	for (instance_map_t::iterator iter = sInstanceMap.begin(); iter != sInstanceMap.end(); ++iter)
-	{
-		instance_list_t& list = iter->second;
-		for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)
-		{
-			LLFloater* floater = *iter;
-			floater->popVisible();
-		}
-	}
-}
-
-//static
-std::string LLFloaterReg::getRectControlName(const std::string& name)
-{
-	return std::string("floater_rect_") + getBaseControlName(name);
-}
-
-//static
-std::string LLFloaterReg::declareRectControl(const std::string& name)
-{
-	std::string controlname = getRectControlName(name);
-	LLFloater::getControlGroup()->declareRect(controlname, LLRect(),
-											  llformat("Window Size for %s", name.c_str()),
-											  LLControlVariable::PERSIST_NONDFT);
-	return controlname;
-}
-
-std::string LLFloaterReg::declarePosXControl(const std::string& name)
-{
-	std::string controlname = std::string("floater_pos_") + getBaseControlName(name) + "_x";
-	LLFloater::getControlGroup()->declareF32(controlname, 
-											10.f,
-											llformat("Window X Position for %s", name.c_str()),
-											LLControlVariable::PERSIST_NONDFT);
-	return controlname;
-}
-
-std::string LLFloaterReg::declarePosYControl(const std::string& name)
-{
-	std::string controlname = std::string("floater_pos_") + getBaseControlName(name) + "_y";
-	LLFloater::getControlGroup()->declareF32(controlname,
-											10.f,
-											llformat("Window Y Position for %s", name.c_str()),
-											LLControlVariable::PERSIST_NONDFT);
-
-	return controlname;
-}
-
-
-//static
-std::string LLFloaterReg::getVisibilityControlName(const std::string& name)
-{
-	return std::string("floater_vis_") + getBaseControlName(name);
-}
-
-//static 
-std::string LLFloaterReg::getBaseControlName(const std::string& name)
-{
-	std::string res(name);
-	LLStringUtil::replaceChar( res, ' ', '_' );
-	return res;
-}
-
-
-//static
-std::string LLFloaterReg::declareVisibilityControl(const std::string& name)
-{
-	std::string controlname = getVisibilityControlName(name);
-	LLFloater::getControlGroup()->declareBOOL(controlname, false,
-												 llformat("Window Visibility for %s", name.c_str()),
-												 LLControlVariable::PERSIST_NONDFT);
-	return controlname;
-}
-
-//static
-std::string LLFloaterReg::declareDockStateControl(const std::string& name)
-{
-	std::string controlname = getDockStateControlName(name);
-	LLFloater::getControlGroup()->declareBOOL(controlname, true,
-												 llformat("Window Docking state for %s", name.c_str()),
-												 LLControlVariable::PERSIST_NONDFT);
-	return controlname;
-
-}
-
-//static
-std::string LLFloaterReg::getDockStateControlName(const std::string& name)
-{
-	std::string res = std::string("floater_dock_") + name;
-	LLStringUtil::replaceChar( res, ' ', '_' );
-	return res;
-}
-
-
-//static
-void LLFloaterReg::registerControlVariables()
-{
-	// Iterate through alll registered instance names and register rect and visibility control variables
-	for (build_map_t::iterator iter = sBuildMap.begin(); iter != sBuildMap.end(); ++iter)
-	{
-		const std::string& name = iter->first;
-		if (LLFloater::getControlGroup()->controlExists(getRectControlName(name)))
-		{
-			declareRectControl(name);
-		}
-		if (LLFloater::getControlGroup()->controlExists(getVisibilityControlName(name)))
-		{
-			declareVisibilityControl(name);
-		}
-	}
-
-	const LLSD& exclude_list = LLUI::getInstance()->mSettingGroups["config"]->getLLSD("always_showable_floaters");
-	for (LLSD::array_const_iterator iter = exclude_list.beginArray();
-		iter != exclude_list.endArray();
-		iter++)
-	{
-		sAlwaysShowableList.insert(iter->asString());
-	}
-}
-
-//static
-void LLFloaterReg::toggleInstanceOrBringToFront(const LLSD& sdname, const LLSD& key)
-{
-	//
-	// Floaters controlled by the toolbar behave a bit differently from others.
-	// Namely they have 3-4 states as defined in the design wiki page here:
-	//   https://wiki.lindenlab.com/wiki/FUI_Button_states
-	//
-	// The basic idea is this:
-	// * If the target floater is minimized, this button press will un-minimize it.
-	// * Else if the target floater is closed open it.
-	// * Else if the target floater does not have focus, give it focus.
-	//       * Also, if it is not on top, bring it forward when focus is given.
-	// * Else the target floater is open, close it.
-	// 
-	std::string name = sdname.asString();
-	LLFloater* instance = getInstance(name, key); 
-	
-	if (!instance)
-	{
-		LL_DEBUGS() << "Unable to get instance of floater '" << name << "'" << LL_ENDL;
-		return;
-	}
-	
-	// If hosted, we need to take that into account
-	LLFloater* host = instance->getHost();
-	
-	if (host)
-	{
-		if (host->isMinimized() || !host->isShown() || !host->isFrontmost())
-		{
-			host->setMinimized(false);
-			instance->openFloater(key);
-			instance->setVisibleAndFrontmost(true, key);
-		}
-		else if (!instance->getVisible())
-		{
-			instance->openFloater(key);
-			instance->setVisibleAndFrontmost(true, key);
-			instance->setFocus(true);
-		}
-		else
-		{
-			instance->closeHostedFloater();
-		}
-	}
-	else
-	{
-		if (instance->isMinimized())
-		{
-			instance->setMinimized(false);
-			instance->setVisibleAndFrontmost(true, key);
-		}
-		else if (!instance->isShown())
-		{
-			instance->openFloater(key);
-			instance->setVisibleAndFrontmost(true, key);
-		}
-		else if (!instance->isFrontmost())
-		{
-			instance->setVisibleAndFrontmost(true, key);
-		}
-		else
-		{
-			instance->closeHostedFloater();
-		}
-	}
-}
-
-// static
-// Same as toggleInstanceOrBringToFront but does not close floater.
-// unlike showInstance() does not trigger onOpen() if already open
-void LLFloaterReg::showInstanceOrBringToFront(const LLSD& sdname, const LLSD& key)
-{
-    std::string name = sdname.asString();
-    LLFloater* instance = getInstance(name, key);
-
-
-    if (!instance)
-    {
-        LL_DEBUGS() << "Unable to get instance of floater '" << name << "'" << LL_ENDL;
-        return;
-    }
-
-    // If hosted, we need to take that into account
-    LLFloater* host = instance->getHost();
-
-    if (host)
-    {
-        if (host->isMinimized() || !host->isShown() || !host->isFrontmost())
-        {
-            host->setMinimized(false);
-            instance->openFloater(key);
-            instance->setVisibleAndFrontmost(true, key);
-        }
-        else if (!instance->getVisible())
-        {
-            instance->openFloater(key);
-            instance->setVisibleAndFrontmost(true, key);
-            instance->setFocus(true);
-        }
-    }
-    else
-    {
-        if (instance->isMinimized())
-        {
-            instance->setMinimized(false);
-            instance->setVisibleAndFrontmost(true, key);
-        }
-        else if (!instance->isShown())
-        {
-            instance->openFloater(key);
-            instance->setVisibleAndFrontmost(true, key);
-        }
-        else if (!instance->isFrontmost())
-        {
-            instance->setVisibleAndFrontmost(true, key);
-        }
-    }
-}
-
-// static
-U32 LLFloaterReg::getVisibleFloaterInstanceCount()
-{
-	U32 count = 0;
-
-	std::map<std::string,std::string>::const_iterator it = sGroupMap.begin(), it_end = sGroupMap.end();
-	for( ; it != it_end; ++it)
-	{
-		const std::string& group_name = it->second;
-
-		instance_list_t& instances = sInstanceMap[group_name];
-
-		for (instance_list_t::const_iterator iter = instances.begin(); iter != instances.end(); ++iter)
-		{
-			LLFloater* inst = *iter;
-
-			if (inst->getVisible() && !inst->isMinimized())
-			{
-				count++;
-			}
-		}
-	}
-
-	return count;
-}
+/**

+ * @file llfloaterreg.cpp

+ * @brief LLFloaterReg Floater Registration Class

+ *

+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2010, Linden Research, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+ *

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

+ * $/LicenseInfo$

+ */

+

+#include "linden_common.h"

+

+#include "llfloaterreg.h"

+

+//#include "llagent.h"

+#include "llfloater.h"

+#include "llmultifloater.h"

+#include "llfloaterreglistener.h"

+#include "lluiusage.h"

+

+//*******************************************************

+

+//static

+LLFloaterReg::instance_list_t LLFloaterReg::sNullInstanceList;

+LLFloaterReg::instance_map_t LLFloaterReg::sInstanceMap;

+LLFloaterReg::build_map_t LLFloaterReg::sBuildMap;

+std::map<std::string,std::string> LLFloaterReg::sGroupMap;

+bool LLFloaterReg::sBlockShowFloaters = false;

+std::set<std::string> LLFloaterReg::sAlwaysShowableList;

+

+static LLFloaterRegListener sFloaterRegListener;

+

+//*******************************************************

+

+//static

+void LLFloaterReg::add(const std::string& name, const std::string& filename, const LLFloaterBuildFunc& func, const std::string& groupname)

+{

+    sBuildMap[name].mFunc = func;

+    sBuildMap[name].mFile = filename;

+    sGroupMap[name] = groupname.empty() ? name : groupname;

+    sGroupMap[groupname] = groupname; // for referencing directly by group name

+}

+

+//static

+bool LLFloaterReg::isRegistered(const std::string& name)

+{

+    return sBuildMap.find(name) != sBuildMap.end();

+}

+

+//static

+LLFloater* LLFloaterReg::getLastFloaterInGroup(const std::string& name)

+{

+    const std::string& groupname = sGroupMap[name];

+    if (!groupname.empty())

+    {

+        instance_list_t& list = sInstanceMap[groupname];

+        if (!list.empty())

+        {

+            for (instance_list_t::reverse_iterator iter = list.rbegin(); iter != list.rend(); ++iter)

+            {

+                LLFloater* inst = *iter;

+

+                if (inst->getVisible() && !inst->isMinimized())

+                {

+                    return inst;

+                }

+            }

+        }

+    }

+    return NULL;

+}

+

+LLFloater* LLFloaterReg::getLastFloaterCascading()

+{

+    LLRect candidate_rect;

+    candidate_rect.mTop = 100000;

+    LLFloater* candidate_floater = NULL;

+

+    std::map<std::string,std::string>::const_iterator it = sGroupMap.begin(), it_end = sGroupMap.end();

+    for( ; it != it_end; ++it)

+    {

+        const std::string& group_name = it->second;

+

+        instance_list_t& instances = sInstanceMap[group_name];

+

+        for (instance_list_t::const_iterator iter = instances.begin(); iter != instances.end(); ++iter)

+        {

+            LLFloater* inst = *iter;

+

+            if (inst->getVisible()

+                && (inst->isPositioning(LLFloaterEnums::POSITIONING_CASCADING)

+                    || inst->isPositioning(LLFloaterEnums::POSITIONING_CASCADE_GROUP)))

+            {

+                if (candidate_rect.mTop > inst->getRect().mTop)

+                {

+                    candidate_floater = inst;

+                    candidate_rect = inst->getRect();

+                }

+            }

+        }

+    }

+

+    return candidate_floater;

+}

+

+//static

+LLFloater* LLFloaterReg::findInstance(const std::string& name, const LLSD& key)

+{

+    LLFloater* res = NULL;

+    const std::string& groupname = sGroupMap[name];

+    if (!groupname.empty())

+    {

+        instance_list_t& list = sInstanceMap[groupname];

+        for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)

+        {

+            LLFloater* inst = *iter;

+            if (inst->matchesKey(key))

+            {

+                res = inst;

+                break;

+            }

+        }

+    }

+    return res;

+}

+

+//static

+LLFloater* LLFloaterReg::getInstance(const std::string& name, const LLSD& key)

+{

+    LLFloater* res = findInstance(name, key);

+    if (!res)

+    {

+        const LLFloaterBuildFunc& build_func = sBuildMap[name].mFunc;

+        const std::string& xui_file = sBuildMap[name].mFile;

+        if (build_func)

+        {

+            const std::string& groupname = sGroupMap[name];

+            if (!groupname.empty())

+            {

+                instance_list_t& list = sInstanceMap[groupname];

+

+                res = build_func(key);

+                if (!res)

+                {

+                    LL_WARNS() << "Failed to build floater type: '" << name << "'." << LL_ENDL;

+                    return NULL;

+                }

+                bool success = res->buildFromFile(xui_file);

+                if (!success)

+                {

+                    LL_WARNS() << "Failed to build floater type: '" << name << "'." << LL_ENDL;

+                    return NULL;

+                }

+

+                // Note: key should eventually be a non optional LLFloater arg; for now, set mKey to be safe

+                if (res->mKey.isUndefined())

+                {

+                    res->mKey = key;

+                }

+                res->setInstanceName(name);

+

+                LLFloater *last_floater = (list.empty() ? NULL : list.back());

+

+                res->applyControlsAndPosition(last_floater);

+

+                gFloaterView->adjustToFitScreen(res, false);

+

+                list.push_back(res);

+            }

+        }

+        if (!res)

+        {

+            LL_WARNS() << "Floater type: '" << name << "' not registered." << LL_ENDL;

+        }

+    }

+    return res;

+}

+

+//static

+LLFloater* LLFloaterReg::removeInstance(const std::string& name, const LLSD& key)

+{

+    LLFloater* res = NULL;

+    const std::string& groupname = sGroupMap[name];

+    if (!groupname.empty())

+    {

+        instance_list_t& list = sInstanceMap[groupname];

+        for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)

+        {

+            LLFloater* inst = *iter;

+            if (inst->matchesKey(key))

+            {

+                res = inst;

+                list.erase(iter);

+                break;

+            }

+        }

+    }

+    return res;

+}

+

+//static

+// returns true if the instance existed

+bool LLFloaterReg::destroyInstance(const std::string& name, const LLSD& key)

+{

+    LLFloater* inst = removeInstance(name, key);

+    if (inst)

+    {

+        delete inst;

+        return true;

+    }

+    else

+    {

+        return false;

+    }

+}

+

+// Iterators

+//static

+LLFloaterReg::const_instance_list_t& LLFloaterReg::getFloaterList(const std::string& name)

+{

+    instance_map_t::iterator iter = sInstanceMap.find(name);

+    if (iter != sInstanceMap.end())

+    {

+        return iter->second;

+    }

+    else

+    {

+        return sNullInstanceList;

+    }

+}

+

+// Visibility Management

+

+//static

+LLFloater* LLFloaterReg::showInstance(const std::string& name, const LLSD& key, bool focus)

+{

+    if( sBlockShowFloaters

+            // see EXT-7090

+            && sAlwaysShowableList.find(name) == sAlwaysShowableList.end())

+        return 0;//

+    LLFloater* instance = getInstance(name, key);

+    if (instance)

+    {

+        instance->openFloater(key);

+        if (focus)

+            instance->setFocus(true);

+    }

+    return instance;

+}

+

+//static

+// returns true if the instance exists

+bool LLFloaterReg::hideInstance(const std::string& name, const LLSD& key)

+{

+    LLFloater* instance = findInstance(name, key);

+    if (instance)

+    {

+        instance->closeHostedFloater();

+    }

+    return (instance != NULL);

+}

+

+//static

+// returns true if the instance is visible when completed

+bool LLFloaterReg::toggleInstance(const std::string& name, const LLSD& key)

+{

+    LLFloater* instance = findInstance(name, key);

+    if (instance && instance->isShown())

+    {

+        instance->closeHostedFloater();

+        return false;

+    }

+

+    instance = showInstance(name, key, true);

+

+    return instance != nullptr;

+}

+

+//static

+// returns true if the instance exists and is visible (doesnt matter minimized or not)

+bool LLFloaterReg::instanceVisible(const std::string& name, const LLSD& key)

+{

+    LLFloater* instance = findInstance(name, key);

+    return LLFloater::isVisible(instance);

+}

+

+//static

+void LLFloaterReg::showInitialVisibleInstances()

+{

+    // Iterate through alll registered instance names and show any with a save visible state

+    for (build_map_t::iterator iter = sBuildMap.begin(); iter != sBuildMap.end(); ++iter)

+    {

+        const std::string& name = iter->first;

+        std::string controlname = getVisibilityControlName(name);

+        if (LLFloater::getControlGroup()->controlExists(controlname))

+        {

+            bool isvis = LLFloater::getControlGroup()->getBOOL(controlname);

+            if (isvis)

+            {

+                showInstance(name, LLSD()); // keyed floaters shouldn't set save_vis to true

+            }

+        }

+    }

+}

+

+//static

+void LLFloaterReg::hideVisibleInstances(const std::set<std::string>& exceptions)

+{

+    // Iterate through alll active instances and hide them

+    for (instance_map_t::iterator iter = sInstanceMap.begin(); iter != sInstanceMap.end(); ++iter)

+    {

+        const std::string& name = iter->first;

+        if (exceptions.find(name) != exceptions.end())

+            continue;

+        instance_list_t& list = iter->second;

+        for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)

+        {

+            LLFloater* floater = *iter;

+            floater->pushVisible(false);

+        }

+    }

+}

+

+//static

+void LLFloaterReg::restoreVisibleInstances()

+{

+    // Iterate through all active instances and restore visibility

+    for (instance_map_t::iterator iter = sInstanceMap.begin(); iter != sInstanceMap.end(); ++iter)

+    {

+        instance_list_t& list = iter->second;

+        for (instance_list_t::iterator iter = list.begin(); iter != list.end(); ++iter)

+        {

+            LLFloater* floater = *iter;

+            floater->popVisible();

+        }

+    }

+}

+

+//static

+std::string LLFloaterReg::getRectControlName(const std::string& name)

+{

+    return std::string("floater_rect_") + getBaseControlName(name);

+}

+

+//static

+std::string LLFloaterReg::declareRectControl(const std::string& name)

+{

+    std::string controlname = getRectControlName(name);

+    LLFloater::getControlGroup()->declareRect(controlname, LLRect(),

+                                              llformat("Window Size for %s", name.c_str()),

+                                              LLControlVariable::PERSIST_NONDFT);

+    return controlname;

+}

+

+std::string LLFloaterReg::declarePosXControl(const std::string& name)

+{

+    std::string controlname = std::string("floater_pos_") + getBaseControlName(name) + "_x";

+    LLFloater::getControlGroup()->declareF32(controlname,

+                                            10.f,

+                                            llformat("Window X Position for %s", name.c_str()),

+                                            LLControlVariable::PERSIST_NONDFT);

+    return controlname;

+}

+

+std::string LLFloaterReg::declarePosYControl(const std::string& name)

+{

+    std::string controlname = std::string("floater_pos_") + getBaseControlName(name) + "_y";

+    LLFloater::getControlGroup()->declareF32(controlname,

+                                            10.f,

+                                            llformat("Window Y Position for %s", name.c_str()),

+                                            LLControlVariable::PERSIST_NONDFT);

+

+    return controlname;

+}

+

+

+//static

+std::string LLFloaterReg::getVisibilityControlName(const std::string& name)

+{

+    return std::string("floater_vis_") + getBaseControlName(name);

+}

+

+//static

+std::string LLFloaterReg::getBaseControlName(const std::string& name)

+{

+    std::string res(name);

+    LLStringUtil::replaceChar( res, ' ', '_' );

+    return res;

+}

+

+

+//static

+std::string LLFloaterReg::declareVisibilityControl(const std::string& name)

+{

+    std::string controlname = getVisibilityControlName(name);

+    LLFloater::getControlGroup()->declareBOOL(controlname, false,

+                                                 llformat("Window Visibility for %s", name.c_str()),

+                                                 LLControlVariable::PERSIST_NONDFT);

+    return controlname;

+}

+

+//static

+std::string LLFloaterReg::declareDockStateControl(const std::string& name)

+{

+    std::string controlname = getDockStateControlName(name);

+    LLFloater::getControlGroup()->declareBOOL(controlname, true,

+                                                 llformat("Window Docking state for %s", name.c_str()),

+                                                 LLControlVariable::PERSIST_NONDFT);

+    return controlname;

+

+}

+

+//static

+std::string LLFloaterReg::getDockStateControlName(const std::string& name)

+{

+    std::string res = std::string("floater_dock_") + name;

+    LLStringUtil::replaceChar( res, ' ', '_' );

+    return res;

+}

+

+

+//static

+void LLFloaterReg::registerControlVariables()

+{

+    // Iterate through alll registered instance names and register rect and visibility control variables

+    for (build_map_t::iterator iter = sBuildMap.begin(); iter != sBuildMap.end(); ++iter)

+    {

+        const std::string& name = iter->first;

+        if (LLFloater::getControlGroup()->controlExists(getRectControlName(name)))

+        {

+            declareRectControl(name);

+        }

+        if (LLFloater::getControlGroup()->controlExists(getVisibilityControlName(name)))

+        {

+            declareVisibilityControl(name);

+        }

+    }

+

+    const LLSD& exclude_list = LLUI::getInstance()->mSettingGroups["config"]->getLLSD("always_showable_floaters");

+    for (LLSD::array_const_iterator iter = exclude_list.beginArray();

+        iter != exclude_list.endArray();

+        iter++)

+    {

+        sAlwaysShowableList.insert(iter->asString());

+    }

+}

+

+//static

+void LLFloaterReg::toggleInstanceOrBringToFront(const LLSD& sdname, const LLSD& key)

+{

+    //

+    // Floaters controlled by the toolbar behave a bit differently from others.

+    // Namely they have 3-4 states as defined in the design wiki page here:

+    //   https://wiki.lindenlab.com/wiki/FUI_Button_states

+    //

+    // The basic idea is this:

+    // * If the target floater is minimized, this button press will un-minimize it.

+    // * Else if the target floater is closed open it.

+    // * Else if the target floater does not have focus, give it focus.

+    //       * Also, if it is not on top, bring it forward when focus is given.

+    // * Else the target floater is open, close it.

+    //

+    std::string name = sdname.asString();

+    LLFloater* instance = getInstance(name, key);

+

+    if (!instance)

+    {

+        LL_DEBUGS() << "Unable to get instance of floater '" << name << "'" << LL_ENDL;

+        return;

+    }

+

+    // If hosted, we need to take that into account

+    LLFloater* host = instance->getHost();

+

+    if (host)

+    {

+        if (host->isMinimized() || !host->isShown() || !host->isFrontmost())

+        {

+            host->setMinimized(false);

+            instance->openFloater(key);

+            instance->setVisibleAndFrontmost(true, key);

+        }

+        else if (!instance->getVisible())

+        {

+            instance->openFloater(key);

+            instance->setVisibleAndFrontmost(true, key);

+            instance->setFocus(true);

+        }

+        else

+        {

+            instance->closeHostedFloater();

+        }

+    }

+    else

+    {

+        if (instance->isMinimized())

+        {

+            instance->setMinimized(false);

+            instance->setVisibleAndFrontmost(true, key);

+        }

+        else if (!instance->isShown())

+        {

+            instance->openFloater(key);

+            instance->setVisibleAndFrontmost(true, key);

+        }

+        else if (!instance->isFrontmost())

+        {

+            instance->setVisibleAndFrontmost(true, key);

+        }

+        else

+        {

+            instance->closeHostedFloater();

+        }

+    }

+}

+

+// static

+// Same as toggleInstanceOrBringToFront but does not close floater.

+// unlike showInstance() does not trigger onOpen() if already open

+void LLFloaterReg::showInstanceOrBringToFront(const LLSD& sdname, const LLSD& key)

+{

+    std::string name = sdname.asString();

+    LLFloater* instance = getInstance(name, key);

+

+

+    if (!instance)

+    {

+        LL_DEBUGS() << "Unable to get instance of floater '" << name << "'" << LL_ENDL;

+        return;

+    }

+

+    // If hosted, we need to take that into account

+    LLFloater* host = instance->getHost();

+

+    if (host)

+    {

+        if (host->isMinimized() || !host->isShown() || !host->isFrontmost())

+        {

+            host->setMinimized(false);

+            instance->openFloater(key);

+            instance->setVisibleAndFrontmost(true, key);

+        }

+        else if (!instance->getVisible())

+        {

+            instance->openFloater(key);

+            instance->setVisibleAndFrontmost(true, key);

+            instance->setFocus(true);

+        }

+    }

+    else

+    {

+        if (instance->isMinimized())

+        {

+            instance->setMinimized(false);

+            instance->setVisibleAndFrontmost(true, key);

+        }

+        else if (!instance->isShown())

+        {

+            instance->openFloater(key);

+            instance->setVisibleAndFrontmost(true, key);

+        }

+        else if (!instance->isFrontmost())

+        {

+            instance->setVisibleAndFrontmost(true, key);

+        }

+    }

+}

+

+// static

+U32 LLFloaterReg::getVisibleFloaterInstanceCount()

+{

+    U32 count = 0;

+

+    std::map<std::string,std::string>::const_iterator it = sGroupMap.begin(), it_end = sGroupMap.end();

+    for( ; it != it_end; ++it)

+    {

+        const std::string& group_name = it->second;

+

+        instance_list_t& instances = sInstanceMap[group_name];

+

+        for (instance_list_t::const_iterator iter = instances.begin(); iter != instances.end(); ++iter)

+        {

+            LLFloater* inst = *iter;

+

+            if (inst->getVisible() && !inst->isMinimized())

+            {

+                count++;

+            }

+        }

+    }

+

+    return count;

+}