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, 461 insertions, 461 deletions

diff --git a/indra/newview/llfloaterspellchecksettings.cpp b/indra/newview/llfloaterspellchecksettings.cpp
index e0eb5261d6..9186c7856a 100644
--- a/indra/newview/llfloaterspellchecksettings.cpp
+++ b/indra/newview/llfloaterspellchecksettings.cpp
@@ -1,461 +1,461 @@
-/** 
- * @file llfloaterspellchecksettings.h
- * @brief Spell checker settings floater
- *
-* $LicenseInfo:firstyear=2011&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 "llviewerprecompiledheaders.h"
-
-#include "llcombobox.h"
-#include "llfilepicker.h"
-#include "llfloaterreg.h"
-#include "llfloaterspellchecksettings.h"
-#include "llnotificationsutil.h"
-#include "llscrolllistctrl.h"
-#include "llsdserialize.h"
-#include "llspellcheck.h"
-#include "lltrans.h"
-#include "llviewercontrol.h"
-#include "llviewermenufile.h" // LLFilePickerReplyThread
-
-#include <boost/algorithm/string.hpp>
-
-///----------------------------------------------------------------------------
-/// Class LLFloaterSpellCheckerSettings
-///----------------------------------------------------------------------------
-LLFloaterSpellCheckerSettings::LLFloaterSpellCheckerSettings(const LLSD& key)
-	: LLFloater(key)
-{
-}
-
-void LLFloaterSpellCheckerSettings::draw()
-{
-	LLFloater::draw();
-
-	std::vector<LLScrollListItem*> sel_items = getChild<LLScrollListCtrl>("spellcheck_available_list")->getAllSelected();
-	bool enable_remove = !sel_items.empty();
-	for (std::vector<LLScrollListItem*>::const_iterator sel_it = sel_items.begin(); sel_it != sel_items.end(); ++sel_it)
-	{
-		enable_remove &= LLSpellChecker::getInstance()->canRemoveDictionary((*sel_it)->getValue().asString());
-	}
-	getChild<LLUICtrl>("spellcheck_remove_btn")->setEnabled(enable_remove);
-}
-
-bool LLFloaterSpellCheckerSettings::postBuild(void)
-{
-	gSavedSettings.getControl("SpellCheck")->getSignal()->connect(boost::bind(&LLFloaterSpellCheckerSettings::refreshDictionaries, this, false));
-	LLSpellChecker::setSettingsChangeCallback(boost::bind(&LLFloaterSpellCheckerSettings::onSpellCheckSettingsChange, this));
-	getChild<LLUICtrl>("spellcheck_remove_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnRemove, this));
-	getChild<LLUICtrl>("spellcheck_import_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnImport, this));
-	getChild<LLUICtrl>("spellcheck_main_combo")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::refreshDictionaries, this, false));
-	getChild<LLUICtrl>("spellcheck_moveleft_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnMove, this, "spellcheck_active_list", "spellcheck_available_list"));
-	getChild<LLUICtrl>("spellcheck_moveright_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnMove, this, "spellcheck_available_list", "spellcheck_active_list"));
-	center();
-	return true;
-}
-
-void LLFloaterSpellCheckerSettings::onBtnImport()
-{
-	LLFloaterReg::showInstance("prefs_spellchecker_import");
-}
-
-void LLFloaterSpellCheckerSettings::onBtnMove(const std::string& from, const std::string& to)
-{
-	LLScrollListCtrl* from_ctrl = findChild<LLScrollListCtrl>(from);
-	LLScrollListCtrl* to_ctrl = findChild<LLScrollListCtrl>(to);
-
-	LLSD row;
-	row["columns"][0]["column"] = "name";
-
-	std::vector<LLScrollListItem*> sel_items = from_ctrl->getAllSelected();
-	std::vector<LLScrollListItem*>::const_iterator sel_it;
-	for ( sel_it = sel_items.begin(); sel_it != sel_items.end(); ++sel_it)
-	{
-		row["value"] = (*sel_it)->getValue();
-		row["columns"][0]["value"] = (*sel_it)->getColumn(0)->getValue();
-		to_ctrl->addElement(row);
-		to_ctrl->setSelectedByValue( (*sel_it)->getValue(), true );
-	}
-	from_ctrl->deleteSelectedItems();
-}
-
-void LLFloaterSpellCheckerSettings::onClose(bool app_quitting)
-{
-	if (app_quitting)
-	{
-		// don't save anything
-		return;
-	}
-	LLFloaterReg::hideInstance("prefs_spellchecker_import");
-	
-	std::list<std::string> list_dict;
-
-	LLComboBox* dict_combo = findChild<LLComboBox>("spellcheck_main_combo");
-	const std::string dict_name = dict_combo->getSelectedItemLabel();
-	if (!dict_name.empty())
-	{
-		list_dict.push_back(dict_name);
-
-		LLScrollListCtrl* list_ctrl = findChild<LLScrollListCtrl>("spellcheck_active_list");
-		std::vector<LLScrollListItem*> list_items = list_ctrl->getAllData();
-		for (std::vector<LLScrollListItem*>::const_iterator item_it = list_items.begin(); item_it != list_items.end(); ++item_it)
-		{
-			const std::string language = (*item_it)->getValue().asString();
-			if (LLSpellChecker::getInstance()->hasDictionary(language, true))
-			{
-				list_dict.push_back(language);
-			}
-		}
-	}
-	gSavedSettings.setString("SpellCheckDictionary", boost::join(list_dict, ","));
-}
-
-void LLFloaterSpellCheckerSettings::onOpen(const LLSD& key)
-{
-	refreshDictionaries(true);
-}
-
-void LLFloaterSpellCheckerSettings::onBtnRemove()
-{
-	std::vector<LLScrollListItem*> sel_items = getChild<LLScrollListCtrl>("spellcheck_available_list")->getAllSelected();
-	for (std::vector<LLScrollListItem*>::const_iterator sel_it = sel_items.begin(); sel_it != sel_items.end(); ++sel_it)
-	{
-		LLSpellChecker::instance().removeDictionary((*sel_it)->getValue().asString());
-	}
-}
-
-void LLFloaterSpellCheckerSettings::onSpellCheckSettingsChange()
-{
-	refreshDictionaries(true);
-}
-
-void LLFloaterSpellCheckerSettings::refreshDictionaries(bool from_settings)
-{
-	bool enabled = gSavedSettings.getBOOL("SpellCheck");
-	getChild<LLUICtrl>("spellcheck_moveleft_btn")->setEnabled(enabled);
-	getChild<LLUICtrl>("spellcheck_moveright_btn")->setEnabled(enabled);
-
-	// Populate the dictionary combobox
-	LLComboBox* dict_combo = findChild<LLComboBox>("spellcheck_main_combo");
-	std::string dict_cur = dict_combo->getSelectedItemLabel();
-	if ((dict_cur.empty() || from_settings) && (LLSpellChecker::getUseSpellCheck()))
-	{
-		dict_cur = LLSpellChecker::instance().getPrimaryDictionary();
-	}
-	dict_combo->clearRows();
-
-	const LLSD& dict_map = LLSpellChecker::getInstance()->getDictionaryMap();
-	if (dict_map.size())
-	{
-		for (LLSD::array_const_iterator dict_it = dict_map.beginArray(); dict_it != dict_map.endArray(); ++dict_it)
-		{
-			const LLSD& dict = *dict_it;
-			if ( (dict["installed"].asBoolean()) && (dict["is_primary"].asBoolean()) && (dict.has("language")) )
-			{
-				dict_combo->add(dict["language"].asString());
-			}
-		}
-		if (!dict_combo->selectByValue(dict_cur))
-		{
-			dict_combo->clear();
-		}
-	}
-	dict_combo->sortByName();
-	dict_combo->setEnabled(enabled);
-
-	// Populate the available and active dictionary list
-	LLScrollListCtrl* avail_ctrl = findChild<LLScrollListCtrl>("spellcheck_available_list");
-	LLScrollListCtrl* active_ctrl = findChild<LLScrollListCtrl>("spellcheck_active_list");
-
-	LLSpellChecker::dict_list_t active_list;
-	if ( ((!avail_ctrl->getItemCount()) && (!active_ctrl->getItemCount())) || (from_settings) )
-	{
-		if (LLSpellChecker::getUseSpellCheck())
-		{
-			active_list = LLSpellChecker::instance().getSecondaryDictionaries();
-		}
-	}
-	else
-	{
-		std::vector<LLScrollListItem*> active_items = active_ctrl->getAllData();
-		for (std::vector<LLScrollListItem*>::const_iterator item_it = active_items.begin(); item_it != active_items.end(); ++item_it)
-		{
-			std::string dict = (*item_it)->getValue().asString();
-			if (dict_cur != dict)
-			{
-				active_list.push_back(dict);
-			}
-		}
-	}
-
-	LLSD row;
-	row["columns"][0]["column"] = "name";
-
-	active_ctrl->clearRows();
-	active_ctrl->setEnabled(enabled);
-	for (LLSpellChecker::dict_list_t::const_iterator it = active_list.begin(); it != active_list.end(); ++it)
-	{
-		const std::string language = *it;
-		const LLSD dict = LLSpellChecker::getInstance()->getDictionaryData(language);
-		row["value"] = language;
-		row["columns"][0]["value"] = (!dict["user_installed"].asBoolean()) ? language : language + " " + LLTrans::getString("UserDictionary");
-		active_ctrl->addElement(row);
-	}
-	active_ctrl->sortByColumnIndex(0, true);
-	active_list.push_back(dict_cur);
-
-	avail_ctrl->clearRows();
-	avail_ctrl->setEnabled(enabled);
-	for (LLSD::array_const_iterator dict_it = dict_map.beginArray(); dict_it != dict_map.endArray(); ++dict_it)
-	{
-		const LLSD& dict = *dict_it;
-		const std::string language = dict["language"].asString();
-		if ( (dict["installed"].asBoolean()) && (active_list.end() == std::find(active_list.begin(), active_list.end(), language)) )
-		{
-			row["value"] = language;
-			row["columns"][0]["value"] = (!dict["user_installed"].asBoolean()) ? language : language + " " + LLTrans::getString("UserDictionary");
-			avail_ctrl->addElement(row);
-		}
-	}
-	avail_ctrl->sortByColumnIndex(0, true);
-}
-
-///----------------------------------------------------------------------------
-/// Class LLFloaterSpellCheckerImport
-///----------------------------------------------------------------------------
-LLFloaterSpellCheckerImport::LLFloaterSpellCheckerImport(const LLSD& key)
-	: LLFloater(key)
-{
-}
-
-bool LLFloaterSpellCheckerImport::postBuild()
-{
-	getChild<LLUICtrl>("dictionary_path_browse")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnBrowse, this));
-	getChild<LLUICtrl>("ok_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnOK, this));
-	getChild<LLUICtrl>("cancel_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnCancel, this));
-	center();
-	return true;
-}
-
-void LLFloaterSpellCheckerImport::onBtnBrowse()
-{
-	LLFilePickerReplyThread::startPicker(boost::bind(&LLFloaterSpellCheckerImport::importSelectedDictionary, this, _1), LLFilePicker::FFLOAD_DICTIONARY, false);
-}
-
-void LLFloaterSpellCheckerImport::importSelectedDictionary(const std::vector<std::string>& filenames)
-{
-	std::string filepath = filenames[0];
-
-	const std::string extension = gDirUtilp->getExtension(filepath);
-	if ("xcu" == extension)
-	{
-		filepath = parseXcuFile(filepath);
-		if (filepath.empty())
-		{
-			return;
-		}
-	}
-
-	getChild<LLUICtrl>("dictionary_path")->setValue(filepath);
-
-	mDictionaryDir = gDirUtilp->getDirName(filepath);
-	mDictionaryBasename = gDirUtilp->getBaseFileName(filepath, true);
-	getChild<LLUICtrl>("dictionary_name")->setValue(mDictionaryBasename);
-}
-
-void LLFloaterSpellCheckerImport::onBtnCancel()
-{
-	closeFloater(false);
-}
-
-void LLFloaterSpellCheckerImport::onBtnOK()
-{
-	const std::string dict_dic = mDictionaryDir + gDirUtilp->getDirDelimiter() + mDictionaryBasename + ".dic";
-	const std::string dict_aff = mDictionaryDir + gDirUtilp->getDirDelimiter() + mDictionaryBasename + ".aff";
-	std::string dict_language = getChild<LLUICtrl>("dictionary_language")->getValue().asString();
-	LLStringUtil::trim(dict_language);
-
-	bool imported = false;
-	if (   dict_language.empty()
-		|| mDictionaryDir.empty()
-		|| mDictionaryBasename.empty()
-		|| ! gDirUtilp->fileExists(dict_dic)
-		)
-	{
-		LLNotificationsUtil::add("SpellingDictImportRequired");
-	}
-	else
-	{
-		std::string settings_dic = LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".dic";
-		if ( LLFile::copy( dict_dic, settings_dic ) )
-		{
-			if (gDirUtilp->fileExists(dict_aff))
-			{
-				std::string settings_aff = LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".aff";
-				if ( LLFile::copy( dict_aff, settings_aff ))
-				{
-					imported = true;
-				}
-				else
-				{
-					LLSD args = LLSD::emptyMap();
-					args["FROM_NAME"] = dict_aff;
-					args["TO_NAME"] = settings_aff;
-					LLNotificationsUtil::add("SpellingDictImportFailed", args);
-				}
-			}
-			else
-			{
-				LLSD args = LLSD::emptyMap();
-				args["DIC_NAME"] = dict_dic;
-				LLNotificationsUtil::add("SpellingDictIsSecondary", args);
-
-				imported = true;
-			}
-		}
-		else
-		{
-			LLSD args = LLSD::emptyMap();
-			args["FROM_NAME"] = dict_dic;
-			args["TO_NAME"] = settings_dic;
-			LLNotificationsUtil::add("SpellingDictImportFailed", args);
-		}
-	}
-
-	if ( imported )
-	{
-		LLSD custom_dict_info;
-		custom_dict_info["is_primary"] = (bool)gDirUtilp->fileExists(dict_aff);
-		custom_dict_info["name"] = mDictionaryBasename;
-		custom_dict_info["language"] = dict_language;
-
-		LLSD custom_dict_map;
-        std::string custom_filename(LLSpellChecker::getDictionaryUserPath() + "user_dictionaries.xml");
-		llifstream custom_file_in(custom_filename.c_str());
-		if (custom_file_in.is_open())
-		{
-			LLSDSerialize::fromXMLDocument(custom_dict_map, custom_file_in);
-			custom_file_in.close();
-		}
-	
-		LLSD::array_iterator it = custom_dict_map.beginArray();
-		for (; it != custom_dict_map.endArray(); ++it)
-		{
-			LLSD& dict_info = *it;
-			if (dict_info["name"].asString() == mDictionaryBasename)
-			{
-				dict_info = custom_dict_info;
-				break;
-			}
-		}
-		if (custom_dict_map.endArray() == it)
-		{
-			custom_dict_map.append(custom_dict_info);
-		}
-
-		llofstream custom_file_out(custom_filename.c_str(), std::ios::trunc);
-		if (custom_file_out.is_open())
-		{
-			LLSDSerialize::toPrettyXML(custom_dict_map, custom_file_out);
-			custom_file_out.close();
-		}
-
-		LLSpellChecker::getInstance()->refreshDictionaryMap();
-	}
-
-	closeFloater(false);
-}
-
-std::string LLFloaterSpellCheckerImport::parseXcuFile(const std::string& file_path) const
-{
-	LLXMLNodePtr xml_root;
-	if ( (!LLUICtrlFactory::getLayeredXMLNode(file_path, xml_root)) || (xml_root.isNull()) )
-	{
-		return LLStringUtil::null;
-	}
-
-	// Bury down to the "Dictionaries" parent node
-	LLXMLNode* dict_node = NULL;
-	for (LLXMLNode* outer_node = xml_root->getFirstChild(); outer_node && !dict_node; outer_node = outer_node->getNextSibling())
-	{
-		std::string temp;
-		if ( (outer_node->getAttributeString("oor:name", temp)) && ("ServiceManager" == temp) )
-		{
-			for (LLXMLNode* inner_node = outer_node->getFirstChild(); inner_node && !dict_node; inner_node = inner_node->getNextSibling())
-			{
-				if ( (inner_node->getAttributeString("oor:name", temp)) && ("Dictionaries" == temp) )
-				{
-					dict_node = inner_node;
-					break;
-				}
-			}
-		}
-	}
-
-	if (dict_node)
-	{
-		// Iterate over all child nodes until we find one that has a <value>DICT_SPELL</value> node
-		for (LLXMLNode* outer_node = dict_node->getFirstChild(); outer_node; outer_node = outer_node->getNextSibling())
-		{
-			std::string temp;
-			LLXMLNodePtr location_node, format_node;
-			for (LLXMLNode* inner_node = outer_node->getFirstChild(); inner_node; inner_node = inner_node->getNextSibling())
-			{
-				if (inner_node->getAttributeString("oor:name", temp))
-				{
-					if ("Locations" == temp)
-					{
-						inner_node->getChild("value", location_node, false);
-					}
-					else if ("Format" == temp)
-					{
-						inner_node->getChild("value", format_node, false);
-					}
-				}
-			}
-			if ( (format_node.isNull()) || ("DICT_SPELL" != format_node->getValue()) || (location_node.isNull()) )
-			{
-				continue;
-			}
-
-			// Found a list of file locations, return the .dic (if present)
-			std::list<std::string> location_list;
-			boost::split(location_list, location_node->getValue(), boost::is_any_of(std::string(" ")));
-			for (std::list<std::string>::iterator it = location_list.begin(); it != location_list.end(); ++it)
-			{
-				std::string& location = *it;
-				if ("\\" != gDirUtilp->getDirDelimiter())
-					LLStringUtil::replaceString(location, "\\", gDirUtilp->getDirDelimiter());
-				else
-					LLStringUtil::replaceString(location, "/", gDirUtilp->getDirDelimiter());
-				LLStringUtil::replaceString(location, "%origin%", gDirUtilp->getDirName(file_path));
-				if ("dic" == gDirUtilp->getExtension(location))
-				{
-					return location;
-				}
-			}
-		}
-	}
-
-	return LLStringUtil::null;
-}
+/**

+ * @file llfloaterspellchecksettings.h

+ * @brief Spell checker settings floater

+ *

+* $LicenseInfo:firstyear=2011&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 "llviewerprecompiledheaders.h"

+

+#include "llcombobox.h"

+#include "llfilepicker.h"

+#include "llfloaterreg.h"

+#include "llfloaterspellchecksettings.h"

+#include "llnotificationsutil.h"

+#include "llscrolllistctrl.h"

+#include "llsdserialize.h"

+#include "llspellcheck.h"

+#include "lltrans.h"

+#include "llviewercontrol.h"

+#include "llviewermenufile.h" // LLFilePickerReplyThread

+

+#include <boost/algorithm/string.hpp>

+

+///----------------------------------------------------------------------------

+/// Class LLFloaterSpellCheckerSettings

+///----------------------------------------------------------------------------

+LLFloaterSpellCheckerSettings::LLFloaterSpellCheckerSettings(const LLSD& key)

+    : LLFloater(key)

+{

+}

+

+void LLFloaterSpellCheckerSettings::draw()

+{

+    LLFloater::draw();

+

+    std::vector<LLScrollListItem*> sel_items = getChild<LLScrollListCtrl>("spellcheck_available_list")->getAllSelected();

+    bool enable_remove = !sel_items.empty();

+    for (std::vector<LLScrollListItem*>::const_iterator sel_it = sel_items.begin(); sel_it != sel_items.end(); ++sel_it)

+    {

+        enable_remove &= LLSpellChecker::getInstance()->canRemoveDictionary((*sel_it)->getValue().asString());

+    }

+    getChild<LLUICtrl>("spellcheck_remove_btn")->setEnabled(enable_remove);

+}

+

+bool LLFloaterSpellCheckerSettings::postBuild(void)

+{

+    gSavedSettings.getControl("SpellCheck")->getSignal()->connect(boost::bind(&LLFloaterSpellCheckerSettings::refreshDictionaries, this, false));

+    LLSpellChecker::setSettingsChangeCallback(boost::bind(&LLFloaterSpellCheckerSettings::onSpellCheckSettingsChange, this));

+    getChild<LLUICtrl>("spellcheck_remove_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnRemove, this));

+    getChild<LLUICtrl>("spellcheck_import_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnImport, this));

+    getChild<LLUICtrl>("spellcheck_main_combo")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::refreshDictionaries, this, false));

+    getChild<LLUICtrl>("spellcheck_moveleft_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnMove, this, "spellcheck_active_list", "spellcheck_available_list"));

+    getChild<LLUICtrl>("spellcheck_moveright_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerSettings::onBtnMove, this, "spellcheck_available_list", "spellcheck_active_list"));

+    center();

+    return true;

+}

+

+void LLFloaterSpellCheckerSettings::onBtnImport()

+{

+    LLFloaterReg::showInstance("prefs_spellchecker_import");

+}

+

+void LLFloaterSpellCheckerSettings::onBtnMove(const std::string& from, const std::string& to)

+{

+    LLScrollListCtrl* from_ctrl = findChild<LLScrollListCtrl>(from);

+    LLScrollListCtrl* to_ctrl = findChild<LLScrollListCtrl>(to);

+

+    LLSD row;

+    row["columns"][0]["column"] = "name";

+

+    std::vector<LLScrollListItem*> sel_items = from_ctrl->getAllSelected();

+    std::vector<LLScrollListItem*>::const_iterator sel_it;

+    for ( sel_it = sel_items.begin(); sel_it != sel_items.end(); ++sel_it)

+    {

+        row["value"] = (*sel_it)->getValue();

+        row["columns"][0]["value"] = (*sel_it)->getColumn(0)->getValue();

+        to_ctrl->addElement(row);

+        to_ctrl->setSelectedByValue( (*sel_it)->getValue(), true );

+    }

+    from_ctrl->deleteSelectedItems();

+}

+

+void LLFloaterSpellCheckerSettings::onClose(bool app_quitting)

+{

+    if (app_quitting)

+    {

+        // don't save anything

+        return;

+    }

+    LLFloaterReg::hideInstance("prefs_spellchecker_import");

+

+    std::list<std::string> list_dict;

+

+    LLComboBox* dict_combo = findChild<LLComboBox>("spellcheck_main_combo");

+    const std::string dict_name = dict_combo->getSelectedItemLabel();

+    if (!dict_name.empty())

+    {

+        list_dict.push_back(dict_name);

+

+        LLScrollListCtrl* list_ctrl = findChild<LLScrollListCtrl>("spellcheck_active_list");

+        std::vector<LLScrollListItem*> list_items = list_ctrl->getAllData();

+        for (std::vector<LLScrollListItem*>::const_iterator item_it = list_items.begin(); item_it != list_items.end(); ++item_it)

+        {

+            const std::string language = (*item_it)->getValue().asString();

+            if (LLSpellChecker::getInstance()->hasDictionary(language, true))

+            {

+                list_dict.push_back(language);

+            }

+        }

+    }

+    gSavedSettings.setString("SpellCheckDictionary", boost::join(list_dict, ","));

+}

+

+void LLFloaterSpellCheckerSettings::onOpen(const LLSD& key)

+{

+    refreshDictionaries(true);

+}

+

+void LLFloaterSpellCheckerSettings::onBtnRemove()

+{

+    std::vector<LLScrollListItem*> sel_items = getChild<LLScrollListCtrl>("spellcheck_available_list")->getAllSelected();

+    for (std::vector<LLScrollListItem*>::const_iterator sel_it = sel_items.begin(); sel_it != sel_items.end(); ++sel_it)

+    {

+        LLSpellChecker::instance().removeDictionary((*sel_it)->getValue().asString());

+    }

+}

+

+void LLFloaterSpellCheckerSettings::onSpellCheckSettingsChange()

+{

+    refreshDictionaries(true);

+}

+

+void LLFloaterSpellCheckerSettings::refreshDictionaries(bool from_settings)

+{

+    bool enabled = gSavedSettings.getBOOL("SpellCheck");

+    getChild<LLUICtrl>("spellcheck_moveleft_btn")->setEnabled(enabled);

+    getChild<LLUICtrl>("spellcheck_moveright_btn")->setEnabled(enabled);

+

+    // Populate the dictionary combobox

+    LLComboBox* dict_combo = findChild<LLComboBox>("spellcheck_main_combo");

+    std::string dict_cur = dict_combo->getSelectedItemLabel();

+    if ((dict_cur.empty() || from_settings) && (LLSpellChecker::getUseSpellCheck()))

+    {

+        dict_cur = LLSpellChecker::instance().getPrimaryDictionary();

+    }

+    dict_combo->clearRows();

+

+    const LLSD& dict_map = LLSpellChecker::getInstance()->getDictionaryMap();

+    if (dict_map.size())

+    {

+        for (LLSD::array_const_iterator dict_it = dict_map.beginArray(); dict_it != dict_map.endArray(); ++dict_it)

+        {

+            const LLSD& dict = *dict_it;

+            if ( (dict["installed"].asBoolean()) && (dict["is_primary"].asBoolean()) && (dict.has("language")) )

+            {

+                dict_combo->add(dict["language"].asString());

+            }

+        }

+        if (!dict_combo->selectByValue(dict_cur))

+        {

+            dict_combo->clear();

+        }

+    }

+    dict_combo->sortByName();

+    dict_combo->setEnabled(enabled);

+

+    // Populate the available and active dictionary list

+    LLScrollListCtrl* avail_ctrl = findChild<LLScrollListCtrl>("spellcheck_available_list");

+    LLScrollListCtrl* active_ctrl = findChild<LLScrollListCtrl>("spellcheck_active_list");

+

+    LLSpellChecker::dict_list_t active_list;

+    if ( ((!avail_ctrl->getItemCount()) && (!active_ctrl->getItemCount())) || (from_settings) )

+    {

+        if (LLSpellChecker::getUseSpellCheck())

+        {

+            active_list = LLSpellChecker::instance().getSecondaryDictionaries();

+        }

+    }

+    else

+    {

+        std::vector<LLScrollListItem*> active_items = active_ctrl->getAllData();

+        for (std::vector<LLScrollListItem*>::const_iterator item_it = active_items.begin(); item_it != active_items.end(); ++item_it)

+        {

+            std::string dict = (*item_it)->getValue().asString();

+            if (dict_cur != dict)

+            {

+                active_list.push_back(dict);

+            }

+        }

+    }

+

+    LLSD row;

+    row["columns"][0]["column"] = "name";

+

+    active_ctrl->clearRows();

+    active_ctrl->setEnabled(enabled);

+    for (LLSpellChecker::dict_list_t::const_iterator it = active_list.begin(); it != active_list.end(); ++it)

+    {

+        const std::string language = *it;

+        const LLSD dict = LLSpellChecker::getInstance()->getDictionaryData(language);

+        row["value"] = language;

+        row["columns"][0]["value"] = (!dict["user_installed"].asBoolean()) ? language : language + " " + LLTrans::getString("UserDictionary");

+        active_ctrl->addElement(row);

+    }

+    active_ctrl->sortByColumnIndex(0, true);

+    active_list.push_back(dict_cur);

+

+    avail_ctrl->clearRows();

+    avail_ctrl->setEnabled(enabled);

+    for (LLSD::array_const_iterator dict_it = dict_map.beginArray(); dict_it != dict_map.endArray(); ++dict_it)

+    {

+        const LLSD& dict = *dict_it;

+        const std::string language = dict["language"].asString();

+        if ( (dict["installed"].asBoolean()) && (active_list.end() == std::find(active_list.begin(), active_list.end(), language)) )

+        {

+            row["value"] = language;

+            row["columns"][0]["value"] = (!dict["user_installed"].asBoolean()) ? language : language + " " + LLTrans::getString("UserDictionary");

+            avail_ctrl->addElement(row);

+        }

+    }

+    avail_ctrl->sortByColumnIndex(0, true);

+}

+

+///----------------------------------------------------------------------------

+/// Class LLFloaterSpellCheckerImport

+///----------------------------------------------------------------------------

+LLFloaterSpellCheckerImport::LLFloaterSpellCheckerImport(const LLSD& key)

+    : LLFloater(key)

+{

+}

+

+bool LLFloaterSpellCheckerImport::postBuild()

+{

+    getChild<LLUICtrl>("dictionary_path_browse")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnBrowse, this));

+    getChild<LLUICtrl>("ok_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnOK, this));

+    getChild<LLUICtrl>("cancel_btn")->setCommitCallback(boost::bind(&LLFloaterSpellCheckerImport::onBtnCancel, this));

+    center();

+    return true;

+}

+

+void LLFloaterSpellCheckerImport::onBtnBrowse()

+{

+    LLFilePickerReplyThread::startPicker(boost::bind(&LLFloaterSpellCheckerImport::importSelectedDictionary, this, _1), LLFilePicker::FFLOAD_DICTIONARY, false);

+}

+

+void LLFloaterSpellCheckerImport::importSelectedDictionary(const std::vector<std::string>& filenames)

+{

+    std::string filepath = filenames[0];

+

+    const std::string extension = gDirUtilp->getExtension(filepath);

+    if ("xcu" == extension)

+    {

+        filepath = parseXcuFile(filepath);

+        if (filepath.empty())

+        {

+            return;

+        }

+    }

+

+    getChild<LLUICtrl>("dictionary_path")->setValue(filepath);

+

+    mDictionaryDir = gDirUtilp->getDirName(filepath);

+    mDictionaryBasename = gDirUtilp->getBaseFileName(filepath, true);

+    getChild<LLUICtrl>("dictionary_name")->setValue(mDictionaryBasename);

+}

+

+void LLFloaterSpellCheckerImport::onBtnCancel()

+{

+    closeFloater(false);

+}

+

+void LLFloaterSpellCheckerImport::onBtnOK()

+{

+    const std::string dict_dic = mDictionaryDir + gDirUtilp->getDirDelimiter() + mDictionaryBasename + ".dic";

+    const std::string dict_aff = mDictionaryDir + gDirUtilp->getDirDelimiter() + mDictionaryBasename + ".aff";

+    std::string dict_language = getChild<LLUICtrl>("dictionary_language")->getValue().asString();

+    LLStringUtil::trim(dict_language);

+

+    bool imported = false;

+    if (   dict_language.empty()

+        || mDictionaryDir.empty()

+        || mDictionaryBasename.empty()

+        || ! gDirUtilp->fileExists(dict_dic)

+        )

+    {

+        LLNotificationsUtil::add("SpellingDictImportRequired");

+    }

+    else

+    {

+        std::string settings_dic = LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".dic";

+        if ( LLFile::copy( dict_dic, settings_dic ) )

+        {

+            if (gDirUtilp->fileExists(dict_aff))

+            {

+                std::string settings_aff = LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".aff";

+                if ( LLFile::copy( dict_aff, settings_aff ))

+                {

+                    imported = true;

+                }

+                else

+                {

+                    LLSD args = LLSD::emptyMap();

+                    args["FROM_NAME"] = dict_aff;

+                    args["TO_NAME"] = settings_aff;

+                    LLNotificationsUtil::add("SpellingDictImportFailed", args);

+                }

+            }

+            else

+            {

+                LLSD args = LLSD::emptyMap();

+                args["DIC_NAME"] = dict_dic;

+                LLNotificationsUtil::add("SpellingDictIsSecondary", args);

+

+                imported = true;

+            }

+        }

+        else

+        {

+            LLSD args = LLSD::emptyMap();

+            args["FROM_NAME"] = dict_dic;

+            args["TO_NAME"] = settings_dic;

+            LLNotificationsUtil::add("SpellingDictImportFailed", args);

+        }

+    }

+

+    if ( imported )

+    {

+        LLSD custom_dict_info;

+        custom_dict_info["is_primary"] = (bool)gDirUtilp->fileExists(dict_aff);

+        custom_dict_info["name"] = mDictionaryBasename;

+        custom_dict_info["language"] = dict_language;

+

+        LLSD custom_dict_map;

+        std::string custom_filename(LLSpellChecker::getDictionaryUserPath() + "user_dictionaries.xml");

+        llifstream custom_file_in(custom_filename.c_str());

+        if (custom_file_in.is_open())

+        {

+            LLSDSerialize::fromXMLDocument(custom_dict_map, custom_file_in);

+            custom_file_in.close();

+        }

+

+        LLSD::array_iterator it = custom_dict_map.beginArray();

+        for (; it != custom_dict_map.endArray(); ++it)

+        {

+            LLSD& dict_info = *it;

+            if (dict_info["name"].asString() == mDictionaryBasename)

+            {

+                dict_info = custom_dict_info;

+                break;

+            }

+        }

+        if (custom_dict_map.endArray() == it)

+        {

+            custom_dict_map.append(custom_dict_info);

+        }

+

+        llofstream custom_file_out(custom_filename.c_str(), std::ios::trunc);

+        if (custom_file_out.is_open())

+        {

+            LLSDSerialize::toPrettyXML(custom_dict_map, custom_file_out);

+            custom_file_out.close();

+        }

+

+        LLSpellChecker::getInstance()->refreshDictionaryMap();

+    }

+

+    closeFloater(false);

+}

+

+std::string LLFloaterSpellCheckerImport::parseXcuFile(const std::string& file_path) const

+{

+    LLXMLNodePtr xml_root;

+    if ( (!LLUICtrlFactory::getLayeredXMLNode(file_path, xml_root)) || (xml_root.isNull()) )

+    {

+        return LLStringUtil::null;

+    }

+

+    // Bury down to the "Dictionaries" parent node

+    LLXMLNode* dict_node = NULL;

+    for (LLXMLNode* outer_node = xml_root->getFirstChild(); outer_node && !dict_node; outer_node = outer_node->getNextSibling())

+    {

+        std::string temp;

+        if ( (outer_node->getAttributeString("oor:name", temp)) && ("ServiceManager" == temp) )

+        {

+            for (LLXMLNode* inner_node = outer_node->getFirstChild(); inner_node && !dict_node; inner_node = inner_node->getNextSibling())

+            {

+                if ( (inner_node->getAttributeString("oor:name", temp)) && ("Dictionaries" == temp) )

+                {

+                    dict_node = inner_node;

+                    break;

+                }

+            }

+        }

+    }

+

+    if (dict_node)

+    {

+        // Iterate over all child nodes until we find one that has a <value>DICT_SPELL</value> node

+        for (LLXMLNode* outer_node = dict_node->getFirstChild(); outer_node; outer_node = outer_node->getNextSibling())

+        {

+            std::string temp;

+            LLXMLNodePtr location_node, format_node;

+            for (LLXMLNode* inner_node = outer_node->getFirstChild(); inner_node; inner_node = inner_node->getNextSibling())

+            {

+                if (inner_node->getAttributeString("oor:name", temp))

+                {

+                    if ("Locations" == temp)

+                    {

+                        inner_node->getChild("value", location_node, false);

+                    }

+                    else if ("Format" == temp)

+                    {

+                        inner_node->getChild("value", format_node, false);

+                    }

+                }

+            }

+            if ( (format_node.isNull()) || ("DICT_SPELL" != format_node->getValue()) || (location_node.isNull()) )

+            {

+                continue;

+            }

+

+            // Found a list of file locations, return the .dic (if present)

+            std::list<std::string> location_list;

+            boost::split(location_list, location_node->getValue(), boost::is_any_of(std::string(" ")));

+            for (std::list<std::string>::iterator it = location_list.begin(); it != location_list.end(); ++it)

+            {

+                std::string& location = *it;

+                if ("\\" != gDirUtilp->getDirDelimiter())

+                    LLStringUtil::replaceString(location, "\\", gDirUtilp->getDirDelimiter());

+                else

+                    LLStringUtil::replaceString(location, "/", gDirUtilp->getDirDelimiter());

+                LLStringUtil::replaceString(location, "%origin%", gDirUtilp->getDirName(file_path));

+                if ("dic" == gDirUtilp->getExtension(location))

+                {

+                    return location;

+                }

+            }

+        }

+    }

+

+    return LLStringUtil::null;

+}