merge

1 files changed, 491 insertions, 0 deletions

diff --git a/indra/newview/llfloaterspellchecksettings.cpp b/indra/newview/llfloaterspellchecksettings.cpp
new file mode 100644
index 0000000000..5ecdd11918
--- /dev/null
+++ b/indra/newview/llfloaterspellchecksettings.cpp
@@ -0,0 +1,491 @@
+/** 
+ * @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 "llscrolllistctrl.h"
+#include "llsdserialize.h"
+#include "llspellcheck.h"
+#include "lltrans.h"
+#include "llviewercontrol.h"
+#include "llnotificationsutil.h"
+
+#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::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::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::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::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(void)
+{
+	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()
+{
+	LLFilePicker& file_picker = LLFilePicker::instance();
+	if (!file_picker.getOpenFile(LLFilePicker::FFLOAD_DICTIONARY))
+	{
+		return;
+	}
+
+	std::string filepath = file_picker.getFirstFile();
+
+	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 ( copyFile( dict_dic, settings_dic ) )
+		{
+			if (gDirUtilp->fileExists(dict_aff))
+			{
+				std::string settings_aff = LLSpellChecker::getDictionaryUserPath() + mDictionaryBasename + ".aff";
+				if (copyFile( 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;
+		llifstream custom_file_in(LLSpellChecker::getDictionaryUserPath() + "user_dictionaries.xml");
+		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(LLSpellChecker::getDictionaryUserPath() + "user_dictionaries.xml", std::ios::trunc);
+		if (custom_file_out.is_open())
+		{
+			LLSDSerialize::toPrettyXML(custom_dict_map, custom_file_out);
+			custom_file_out.close();
+		}
+
+		LLSpellChecker::refreshDictionaryMap();
+	}
+
+	closeFloater(false);
+}
+
+bool LLFloaterSpellCheckerImport::copyFile(const std::string from, const std::string to)
+{
+	bool copied = false;
+	LLFILE* in = LLFile::fopen(from, "rb");		/* Flawfinder: ignore */	 	
+	if (in)	 	
+	{	 	
+		LLFILE* out = LLFile::fopen(to, "wb");		/* Flawfinder: ignore */
+		if (out)
+		{
+			char buf[16384];		/* Flawfinder: ignore */ 	
+			size_t readbytes;
+			bool write_ok = true;
+			while(write_ok && (readbytes = fread(buf, 1, 16384, in))) /* Flawfinder: ignore */
+			{
+				if (fwrite(buf, 1, readbytes, out) != readbytes)
+				{
+					LL_WARNS("SpellCheck") << "Short write" << LL_ENDL; 
+					write_ok = false;
+				}
+			}
+			if ( write_ok )
+			{
+				copied = true;
+			}
+			fclose(out);
+		}
+	}
+	fclose(in);
+	return copied;
+}
+
+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;
+}