Manual whitespace fixes (fix_whitespace.py).

2 files changed, 1222 insertions, 1222 deletions

diff --git a/indra/llxml/llcontrol.cpp b/indra/llxml/llcontrol.cpp
index a2178ed77d..1194e0c3bc 100644
--- a/indra/llxml/llcontrol.cpp
+++ b/indra/llxml/llcontrol.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llcontrol.cpp
  * @brief Holds global state for viewer.
  *
  * $LicenseInfo:firstyear=2001&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$
  */
@@ -109,60 +109,60 @@ std::string SETTINGS_PROFILE = "settings_profile.log";
 
 bool LLControlVariable::llsd_compare(const LLSD& a, const LLSD & b)
 {
-	bool result = false;
-	switch (mType)
-	{
-	case TYPE_U32:
-	case TYPE_S32:
-		result = a.asInteger() == b.asInteger();
-		break;
-	case TYPE_BOOLEAN:
-		result = a.asBoolean() == b.asBoolean();
-		break;
-	case TYPE_F32:
-		result = a.asReal() == b.asReal();
-		break;
-	case TYPE_VEC3:
-	case TYPE_VEC3D:
-		result = LLVector3d(a) == LLVector3d(b);
-		break;
-	case TYPE_QUAT:
-		result = LLQuaternion(a) == LLQuaternion(b);
-		break;
-	case TYPE_RECT:
-		result = LLRect(a) == LLRect(b);
-		break;
-	case TYPE_COL4:
-		result = LLColor4(a) == LLColor4(b);
-		break;
-	case TYPE_COL3:
-		result = LLColor3(a) == LLColor3(b);
-		break;
-	case TYPE_STRING:
-		result = a.asString() == b.asString();
-		break;
-	default:
-		break;
-	}
-
-	return result;
+    bool result = false;
+    switch (mType)
+    {
+    case TYPE_U32:
+    case TYPE_S32:
+        result = a.asInteger() == b.asInteger();
+        break;
+    case TYPE_BOOLEAN:
+        result = a.asBoolean() == b.asBoolean();
+        break;
+    case TYPE_F32:
+        result = a.asReal() == b.asReal();
+        break;
+    case TYPE_VEC3:
+    case TYPE_VEC3D:
+        result = LLVector3d(a) == LLVector3d(b);
+        break;
+    case TYPE_QUAT:
+        result = LLQuaternion(a) == LLQuaternion(b);
+        break;
+    case TYPE_RECT:
+        result = LLRect(a) == LLRect(b);
+        break;
+    case TYPE_COL4:
+        result = LLColor4(a) == LLColor4(b);
+        break;
+    case TYPE_COL3:
+        result = LLColor3(a) == LLColor3(b);
+        break;
+    case TYPE_STRING:
+        result = a.asString() == b.asString();
+        break;
+    default:
+        break;
+    }
+
+    return result;
 }
 
 LLControlVariable::LLControlVariable(const std::string& name, eControlType type,
-							 LLSD initial, const std::string& comment,
-							 ePersist persist, bool hidefromsettingseditor)
-	: mName(name),
-	  mComment(comment),
-	  mType(type),
-	  mPersist(persist),
-	  mHideFromSettingsEditor(hidefromsettingseditor)
-{
-	if ((persist != PERSIST_NO) && mComment.empty())
-	{
-		LL_ERRS() << "Must supply a comment for control " << mName << LL_ENDL;
-	}
-	//Push back versus setValue'ing here, since we don't want to call a signal yet
-	mValues.push_back(initial);
+                             LLSD initial, const std::string& comment,
+                             ePersist persist, bool hidefromsettingseditor)
+    : mName(name),
+      mComment(comment),
+      mType(type),
+      mPersist(persist),
+      mHideFromSettingsEditor(hidefromsettingseditor)
+{
+    if ((persist != PERSIST_NO) && mComment.empty())
+    {
+        LL_ERRS() << "Must supply a comment for control " << mName << LL_ENDL;
+    }
+    //Push back versus setValue'ing here, since we don't want to call a signal yet
+    mValues.push_back(initial);
 }
 
 
@@ -173,70 +173,70 @@ LLControlVariable::~LLControlVariable()
 
 LLSD LLControlVariable::getComparableValue(const LLSD& value)
 {
-	// *FIX:MEP - The following is needed to make the LLSD::ImplString 
-	// work with boolean controls...
-	LLSD storable_value;
-	if(TYPE_BOOLEAN == type() && value.isString())
-	{
-		BOOL temp;
-		if(LLStringUtil::convertToBOOL(value.asString(), temp)) 
-		{
-			storable_value = (bool)temp;
-		}
-		else
-		{
-			storable_value = false;
-		}
-	}
-	else if (TYPE_LLSD == type() && value.isString())
-	{
-		LLPointer<LLSDNotationParser> parser = new LLSDNotationParser;
-		LLSD result;
-		std::stringstream value_stream(value.asString());
-		if (parser->parse(value_stream, result, LLSDSerialize::SIZE_UNLIMITED) != LLSDParser::PARSE_FAILURE)
-		{
-			storable_value = result;
-		}
-		else
-		{
-			storable_value = value;
-		}
-	}
-	else
-	{
-		storable_value = value;
-	}
-
-	return storable_value;
+    // *FIX:MEP - The following is needed to make the LLSD::ImplString
+    // work with boolean controls...
+    LLSD storable_value;
+    if(TYPE_BOOLEAN == type() && value.isString())
+    {
+        BOOL temp;
+        if(LLStringUtil::convertToBOOL(value.asString(), temp))
+        {
+            storable_value = (bool)temp;
+        }
+        else
+        {
+            storable_value = false;
+        }
+    }
+    else if (TYPE_LLSD == type() && value.isString())
+    {
+        LLPointer<LLSDNotationParser> parser = new LLSDNotationParser;
+        LLSD result;
+        std::stringstream value_stream(value.asString());
+        if (parser->parse(value_stream, result, LLSDSerialize::SIZE_UNLIMITED) != LLSDParser::PARSE_FAILURE)
+        {
+            storable_value = result;
+        }
+        else
+        {
+            storable_value = value;
+        }
+    }
+    else
+    {
+        storable_value = value;
+    }
+
+    return storable_value;
 }
 
 void LLControlVariable::setValue(const LLSD& new_value, bool saved_value)
 {
-	if (mValidateSignal(this, new_value) == false)
-	{
-		// can not set new value, exit
-		return;
-	}
-	
-	LLSD storable_value = getComparableValue(new_value);
-	LLSD original_value = getValue();
-	bool value_changed = llsd_compare(original_value, storable_value) == FALSE;
-	if(saved_value)
-	{
-    	// If we're going to save this value, return to default but don't fire
-		resetToDefault(false);
-	    if (llsd_compare(mValues.back(), storable_value) == FALSE)
-	    {
-		    mValues.push_back(storable_value);
-	    }
-	}
+    if (mValidateSignal(this, new_value) == false)
+    {
+        // can not set new value, exit
+        return;
+    }
+
+    LLSD storable_value = getComparableValue(new_value);
+    LLSD original_value = getValue();
+    bool value_changed = llsd_compare(original_value, storable_value) == FALSE;
+    if(saved_value)
+    {
+        // If we're going to save this value, return to default but don't fire
+        resetToDefault(false);
+        if (llsd_compare(mValues.back(), storable_value) == FALSE)
+        {
+            mValues.push_back(storable_value);
+        }
+    }
     else
     {
         // This is an unsaved value. Its needs to reside at
-        // mValues[2] (or greater). It must not affect 
+        // mValues[2] (or greater). It must not affect
         // the result of getSaveValue()
-	    if (llsd_compare(mValues.back(), storable_value) == FALSE)
-	    {
+        if (llsd_compare(mValues.back(), storable_value) == FALSE)
+        {
             while(mValues.size() > 2)
             {
                 // Remove any unsaved values.
@@ -251,107 +251,107 @@ void LLControlVariable::setValue(const LLSD& new_value, bool saved_value)
 
             // Add the 'un-save' value.
             mValues.push_back(storable_value);
-	    }
+        }
     }
 
     if(value_changed)
     {
-		firePropertyChanged(original_value);
+        firePropertyChanged(original_value);
     }
 }
 
 void LLControlVariable::setDefaultValue(const LLSD& value)
 {
-	// Set the control variables value and make it 
-	// the default value. If the active value is changed,
-	// send the signal.
-	// *NOTE: Default values are not saved, only read.
+    // Set the control variables value and make it
+    // the default value. If the active value is changed,
+    // send the signal.
+    // *NOTE: Default values are not saved, only read.
 
-	LLSD comparable_value = getComparableValue(value);
-	LLSD original_value = getValue();
-	bool value_changed = (llsd_compare(original_value, comparable_value) == FALSE);
-	resetToDefault(false);
-	mValues[0] = comparable_value;
-	if(value_changed)
-	{
-		firePropertyChanged(original_value);
-	}
+    LLSD comparable_value = getComparableValue(value);
+    LLSD original_value = getValue();
+    bool value_changed = (llsd_compare(original_value, comparable_value) == FALSE);
+    resetToDefault(false);
+    mValues[0] = comparable_value;
+    if(value_changed)
+    {
+        firePropertyChanged(original_value);
+    }
 }
 
 void LLControlVariable::setPersist(ePersist state)
 {
-	mPersist = state;
+    mPersist = state;
 }
 
 void LLControlVariable::setHiddenFromSettingsEditor(bool hide)
 {
-	mHideFromSettingsEditor = hide;
+    mHideFromSettingsEditor = hide;
 }
 
 void LLControlVariable::setComment(const std::string& comment)
 {
-	mComment = comment;
+    mComment = comment;
 }
 
 void LLControlVariable::resetToDefault(bool fire_signal)
 {
-	//The first setting is always the default
-	//Pop to it and fire off the listener
-	LLSD originalValue = mValues.back();
+    //The first setting is always the default
+    //Pop to it and fire off the listener
+    LLSD originalValue = mValues.back();
 
-	while(mValues.size() > 1)
-	{
-		mValues.pop_back();
-	}
-	
-	if(fire_signal) 
-	{
-		firePropertyChanged(originalValue);
-	}
+    while(mValues.size() > 1)
+    {
+        mValues.pop_back();
+    }
+
+    if(fire_signal)
+    {
+        firePropertyChanged(originalValue);
+    }
 }
 
 bool LLControlVariable::shouldSave(bool nondefault_only)
 {
-	// This method is used to decide whether we should save a given
-	// variable. Two of the three values of mPersist are easy.
-	if (mPersist == PERSIST_NO)
-		return false;
+    // This method is used to decide whether we should save a given
+    // variable. Two of the three values of mPersist are easy.
+    if (mPersist == PERSIST_NO)
+        return false;
 
-	if (mPersist == PERSIST_ALWAYS)
-		return true;
+    if (mPersist == PERSIST_ALWAYS)
+        return true;
 
-	// PERSIST_NONDFT
-	// If caller doesn't need us to filter, just save.
-	if (! nondefault_only)
-		return true;
+    // PERSIST_NONDFT
+    // If caller doesn't need us to filter, just save.
+    if (! nondefault_only)
+        return true;
 
-	// PERSIST_NONDFT: caller only wants us to save this variable if its value
-	// differs from default.
-	if (isDefault())                // never been altered
-		return false;
+    // PERSIST_NONDFT: caller only wants us to save this variable if its value
+    // differs from default.
+    if (isDefault())                // never been altered
+        return false;
 
-	// We've set at least one other value: compare it to default. Save only if
-	// they differ.
-	return ! llsd_compare(getSaveValue(), getDefault());
+    // We've set at least one other value: compare it to default. Save only if
+    // they differ.
+    return ! llsd_compare(getSaveValue(), getDefault());
 }
 
 LLSD LLControlVariable::getSaveValue() const
 {
-	//The first level of the stack is default
-	//We assume that the second level is user preferences that should be saved
-	if(mValues.size() > 1) return mValues[1];
-	return mValues[0];
+    //The first level of the stack is default
+    //We assume that the second level is user preferences that should be saved
+    if(mValues.size() > 1) return mValues[1];
+    return mValues[0];
 }
 
 LLPointer<LLControlVariable> LLControlGroup::getControl(const std::string& name)
 {
-	if (mSettingsProfile)
-	{
-		incrCount(name);
-	}
+    if (mSettingsProfile)
+    {
+        incrCount(name);
+    }
 
-	ctrl_name_table_t::iterator iter = mNameTable.find(name);
-	return iter == mNameTable.end() ? LLPointer<LLControlVariable>() : iter->second;
+    ctrl_name_table_t::iterator iter = mNameTable.find(name);
+    return iter == mNameTable.end() ? LLPointer<LLControlVariable>() : iter->second;
 }
 
 
@@ -373,296 +373,296 @@ const std::string LLControlGroup::mTypeString[TYPE_COUNT] = { "U32"
                                                              };
 
 LLControlGroup::LLControlGroup(const std::string& name)
-:	LLInstanceTracker<LLControlGroup, std::string>(name),
-	mSettingsProfile(false)
+:   LLInstanceTracker<LLControlGroup, std::string>(name),
+    mSettingsProfile(false)
 {
 
-	if (NULL != getenv("LL_SETTINGS_PROFILE"))
-	{
-		mSettingsProfile = true;
-	}
+    if (NULL != getenv("LL_SETTINGS_PROFILE"))
+    {
+        mSettingsProfile = true;
+    }
 }
 
 LLControlGroup::~LLControlGroup()
 {
-	cleanup();
+    cleanup();
 }
 
 static bool compareRoutine(settings_pair_t lhs, settings_pair_t rhs)
 {
-	return lhs.second > rhs.second;
+    return lhs.second > rhs.second;
 };
 
 void LLControlGroup::cleanup()
 {
-	if(mSettingsProfile && getCount.size() != 0)
-	{
-		std::string file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, SETTINGS_PROFILE);
-		LLFILE* out = LLFile::fopen(file, "w"); /* Flawfinder: ignore */
-		if(!out)
-		{
-			LL_WARNS("SettingsProfile") << "Error opening " << SETTINGS_PROFILE << LL_ENDL;
-		}
-		else
-		{
-			F64 end_time = LLTimer::getTotalSeconds();
-			U32 total_seconds = (U32)(end_time - start_time);
-
-			std::string msg = llformat("Runtime (seconds): %d\n\n No. accesses   Avg. accesses/sec  Name\n", total_seconds);
-			std::ostringstream data_msg;
-
-			data_msg << msg;
-			size_t data_size = data_msg.str().size();
-			if (fwrite(data_msg.str().c_str(), 1, data_size, out) != data_size)
-			{
-				LL_WARNS("SettingsProfile") << "Failed to write settings profile header" << LL_ENDL;
-			}
-
-			for (LLSD::map_const_iterator iter = getCount.beginMap(); iter != getCount.endMap(); ++iter)
-			{
-				getCount_v.push_back(settings_pair_t(iter->first, iter->second.asInteger()));
-			}
-			sort(getCount_v.begin(), getCount_v.end(), compareRoutine);
-
-			for (settings_vec_t::iterator iter = getCount_v.begin(); iter != getCount_v.end(); ++iter)
-			{
-				U32 access_rate = 0;
-				if (total_seconds != 0)
-				{
-					access_rate = iter->second / total_seconds;
-				}
-				if (access_rate >= 2)
-				{
-					std::ostringstream data_msg;
-					msg = llformat("%13d        %7d       %s", iter->second, access_rate, iter->first.c_str());
-					data_msg << msg << "\n";
-					size_t data_size = data_msg.str().size();
-					if (fwrite(data_msg.str().c_str(), 1, data_size, out) != data_size)
-					{
-						LL_WARNS("SettingsProfile") << "Failed to write settings profile" << LL_ENDL;
-					}
-				}
-			}
-			getCount = LLSD::emptyMap();
-			fclose(out);
-		}
-	}
-
-	mNameTable.clear();
+    if(mSettingsProfile && getCount.size() != 0)
+    {
+        std::string file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, SETTINGS_PROFILE);
+        LLFILE* out = LLFile::fopen(file, "w"); /* Flawfinder: ignore */
+        if(!out)
+        {
+            LL_WARNS("SettingsProfile") << "Error opening " << SETTINGS_PROFILE << LL_ENDL;
+        }
+        else
+        {
+            F64 end_time = LLTimer::getTotalSeconds();
+            U32 total_seconds = (U32)(end_time - start_time);
+
+            std::string msg = llformat("Runtime (seconds): %d\n\n No. accesses   Avg. accesses/sec  Name\n", total_seconds);
+            std::ostringstream data_msg;
+
+            data_msg << msg;
+            size_t data_size = data_msg.str().size();
+            if (fwrite(data_msg.str().c_str(), 1, data_size, out) != data_size)
+            {
+                LL_WARNS("SettingsProfile") << "Failed to write settings profile header" << LL_ENDL;
+            }
+
+            for (LLSD::map_const_iterator iter = getCount.beginMap(); iter != getCount.endMap(); ++iter)
+            {
+                getCount_v.push_back(settings_pair_t(iter->first, iter->second.asInteger()));
+            }
+            sort(getCount_v.begin(), getCount_v.end(), compareRoutine);
+
+            for (settings_vec_t::iterator iter = getCount_v.begin(); iter != getCount_v.end(); ++iter)
+            {
+                U32 access_rate = 0;
+                if (total_seconds != 0)
+                {
+                    access_rate = iter->second / total_seconds;
+                }
+                if (access_rate >= 2)
+                {
+                    std::ostringstream data_msg;
+                    msg = llformat("%13d        %7d       %s", iter->second, access_rate, iter->first.c_str());
+                    data_msg << msg << "\n";
+                    size_t data_size = data_msg.str().size();
+                    if (fwrite(data_msg.str().c_str(), 1, data_size, out) != data_size)
+                    {
+                        LL_WARNS("SettingsProfile") << "Failed to write settings profile" << LL_ENDL;
+                    }
+                }
+            }
+            getCount = LLSD::emptyMap();
+            fclose(out);
+        }
+    }
+
+    mNameTable.clear();
 }
 
 eControlType LLControlGroup::typeStringToEnum(const std::string& typestr)
 {
-	for(int i = 0; i < (int)TYPE_COUNT; ++i)
-	{
-		if(mTypeString[i] == typestr) return (eControlType)i;
-	}
-	return (eControlType)-1;
+    for(int i = 0; i < (int)TYPE_COUNT; ++i)
+    {
+        if(mTypeString[i] == typestr) return (eControlType)i;
+    }
+    return (eControlType)-1;
 }
 
 std::string LLControlGroup::typeEnumToString(eControlType typeenum)
 {
-	return mTypeString[typeenum];
+    return mTypeString[typeenum];
 }
 
 LLControlVariable* LLControlGroup::declareControl(const std::string& name, eControlType type, const LLSD initial_val, const std::string& comment, LLControlVariable::ePersist persist, BOOL hidefromsettingseditor)
 {
-	LLControlVariable* existing_control = getControl(name);
-	if (existing_control)
- 	{
-		if ((persist != LLControlVariable::PERSIST_NO) && existing_control->isType(type))
-		{
-			if (!existing_control->llsd_compare(existing_control->getDefault(), initial_val))
-			{
-				// Sometimes we need to declare a control *after* it has been loaded from a settings file.
-				LLSD cur_value = existing_control->getValue(); // get the current value
-				existing_control->setDefaultValue(initial_val); // set the default to the declared value
-				existing_control->setValue(cur_value); // now set to the loaded value
-			}
-		}
-		else
-		{
-			LL_WARNS("Settings") << "Control named " << name << " already exists, ignoring new declaration." << LL_ENDL;
-		}
- 		return existing_control;
-	}
-
-	// if not, create the control and add it to the name table
-	LLControlVariable* control = new LLControlVariable(name, type, initial_val, comment, persist, hidefromsettingseditor);
-	mNameTable[name] = control;	
-	return control;
+    LLControlVariable* existing_control = getControl(name);
+    if (existing_control)
+    {
+        if ((persist != LLControlVariable::PERSIST_NO) && existing_control->isType(type))
+        {
+            if (!existing_control->llsd_compare(existing_control->getDefault(), initial_val))
+            {
+                // Sometimes we need to declare a control *after* it has been loaded from a settings file.
+                LLSD cur_value = existing_control->getValue(); // get the current value
+                existing_control->setDefaultValue(initial_val); // set the default to the declared value
+                existing_control->setValue(cur_value); // now set to the loaded value
+            }
+        }
+        else
+        {
+            LL_WARNS("Settings") << "Control named " << name << " already exists, ignoring new declaration." << LL_ENDL;
+        }
+        return existing_control;
+    }
+
+    // if not, create the control and add it to the name table
+    LLControlVariable* control = new LLControlVariable(name, type, initial_val, comment, persist, hidefromsettingseditor);
+    mNameTable[name] = control;
+    return control;
 }
 
 LLControlVariable* LLControlGroup::declareU32(const std::string& name, const U32 initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_U32, (LLSD::Integer) initial_val, comment, persist);
+    return declareControl(name, TYPE_U32, (LLSD::Integer) initial_val, comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareS32(const std::string& name, const S32 initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_S32, initial_val, comment, persist);
+    return declareControl(name, TYPE_S32, initial_val, comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareF32(const std::string& name, const F32 initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_F32, initial_val, comment, persist);
+    return declareControl(name, TYPE_F32, initial_val, comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareBOOL(const std::string& name, const BOOL initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_BOOLEAN, initial_val, comment, persist);
+    return declareControl(name, TYPE_BOOLEAN, initial_val, comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareString(const std::string& name, const std::string& initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_STRING, initial_val, comment, persist);
+    return declareControl(name, TYPE_STRING, initial_val, comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareVec3(const std::string& name, const LLVector3 &initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_VEC3, initial_val.getValue(), comment, persist);
+    return declareControl(name, TYPE_VEC3, initial_val.getValue(), comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareVec3d(const std::string& name, const LLVector3d &initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_VEC3D, initial_val.getValue(), comment, persist);
+    return declareControl(name, TYPE_VEC3D, initial_val.getValue(), comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareQuat(const std::string& name, const LLQuaternion &initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_QUAT, initial_val.getValue(), comment, persist);
+    return declareControl(name, TYPE_QUAT, initial_val.getValue(), comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareRect(const std::string& name, const LLRect &initial_val, const std::string& comment, LLControlVariable::ePersist persist)
 {
-	return declareControl(name, TYPE_RECT, initial_val.getValue(), comment, persist);
+    return declareControl(name, TYPE_RECT, initial_val.getValue(), comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareColor4(const std::string& name, const LLColor4 &initial_val, const std::string& comment, LLControlVariable::ePersist persist )
 {
-	return declareControl(name, TYPE_COL4, initial_val.getValue(), comment, persist);
+    return declareControl(name, TYPE_COL4, initial_val.getValue(), comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareColor3(const std::string& name, const LLColor3 &initial_val, const std::string& comment, LLControlVariable::ePersist persist )
 {
-	return declareControl(name, TYPE_COL3, initial_val.getValue(), comment, persist);
+    return declareControl(name, TYPE_COL3, initial_val.getValue(), comment, persist);
 }
 
 LLControlVariable* LLControlGroup::declareLLSD(const std::string& name, const LLSD &initial_val, const std::string& comment, LLControlVariable::ePersist persist )
 {
-	return declareControl(name, TYPE_LLSD, initial_val, comment, persist);
+    return declareControl(name, TYPE_LLSD, initial_val, comment, persist);
 }
 
 void LLControlGroup::incrCount(const std::string& name)
 {
-	if (0.0 == start_time)
-	{
-		start_time = LLTimer::getTotalSeconds();
-	}
-	getCount[name] = getCount[name].asInteger() + 1;
+    if (0.0 == start_time)
+    {
+        start_time = LLTimer::getTotalSeconds();
+    }
+    getCount[name] = getCount[name].asInteger() + 1;
 }
 
 BOOL LLControlGroup::getBOOL(const std::string& name)
 {
-	return (BOOL)get<bool>(name);
+    return (BOOL)get<bool>(name);
 }
 
 S32 LLControlGroup::getS32(const std::string& name)
 {
-	return get<S32>(name);
+    return get<S32>(name);
 }
 
 U32 LLControlGroup::getU32(const std::string& name)
 {
-	return get<U32>(name);
+    return get<U32>(name);
 }
 
 F32 LLControlGroup::getF32(const std::string& name)
 {
-	return get<F32>(name);
+    return get<F32>(name);
 }
 
 std::string LLControlGroup::getString(const std::string& name)
 {
-	return get<std::string>(name);
+    return get<std::string>(name);
 }
 
 LLWString LLControlGroup::getWString(const std::string& name)
 {
-	return get<LLWString>(name);
+    return get<LLWString>(name);
 }
 
 std::string LLControlGroup::getText(const std::string& name)
 {
-	std::string utf8_string = getString(name);
-	LLStringUtil::replaceChar(utf8_string, '^', '\n');
-	LLStringUtil::replaceChar(utf8_string, '%', ' ');
-	return (utf8_string);
+    std::string utf8_string = getString(name);
+    LLStringUtil::replaceChar(utf8_string, '^', '\n');
+    LLStringUtil::replaceChar(utf8_string, '%', ' ');
+    return (utf8_string);
 }
 
 LLVector3 LLControlGroup::getVector3(const std::string& name)
 {
-	return get<LLVector3>(name);
+    return get<LLVector3>(name);
 }
 
 LLVector3d LLControlGroup::getVector3d(const std::string& name)
 {
-	return get<LLVector3d>(name);
+    return get<LLVector3d>(name);
 }
 
 LLQuaternion LLControlGroup::getQuaternion(const std::string& name)
 {
-	return get<LLQuaternion>(name);
+    return get<LLQuaternion>(name);
 }
 
 LLRect LLControlGroup::getRect(const std::string& name)
 {
-	return get<LLRect>(name);
+    return get<LLRect>(name);
 }
 
 
 LLColor4 LLControlGroup::getColor(const std::string& name)
 {
-	return get<LLColor4>(name);
+    return get<LLColor4>(name);
 }
 
 LLColor4 LLControlGroup::getColor4(const std::string& name)
 {
-	return get<LLColor4>(name);
+    return get<LLColor4>(name);
 }
 
 LLColor3 LLControlGroup::getColor3(const std::string& name)
 {
-	return get<LLColor3>(name);
+    return get<LLColor3>(name);
 }
 
 LLSD LLControlGroup::getLLSD(const std::string& name)
 {
-	return get<LLSD>(name);
+    return get<LLSD>(name);
 }
 
 LLSD LLControlGroup::asLLSD(bool diffs_only)
 {
-	// Dump all stored values as LLSD
-	LLSD result = LLSD::emptyArray();
-	for (ctrl_name_table_t::iterator iter = mNameTable.begin();
-		 iter != mNameTable.end(); iter++)
-	{
-		LLControlVariable *control = iter->second;
-		if (!control || control->isType(TYPE_STRING) || (diffs_only && control->isDefault()))
-		{
-			continue;
-		}
-		const std::string& name = iter->first;
-		result[name] = getLLSD(name);
-	}
-	return result;
+    // Dump all stored values as LLSD
+    LLSD result = LLSD::emptyArray();
+    for (ctrl_name_table_t::iterator iter = mNameTable.begin();
+         iter != mNameTable.end(); iter++)
+    {
+        LLControlVariable *control = iter->second;
+        if (!control || control->isType(TYPE_STRING) || (diffs_only && control->isDefault()))
+        {
+            continue;
+        }
+        const std::string& name = iter->first;
+        result[name] = getLLSD(name);
+    }
+    return result;
 }
 
 BOOL LLControlGroup::controlExists(const std::string& name)
 {
-	ctrl_name_table_t::iterator iter = mNameTable.find(name);
-	return iter != mNameTable.end();
+    ctrl_name_table_t::iterator iter = mNameTable.find(name);
+    return iter != mNameTable.end();
 }
 
 
@@ -672,81 +672,81 @@ BOOL LLControlGroup::controlExists(const std::string& name)
 
 void LLControlGroup::setBOOL(const std::string& name, BOOL val)
 {
-	set<bool>(name, val);
+    set<bool>(name, val);
 }
 
 
 void LLControlGroup::setS32(const std::string& name, S32 val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 
 void LLControlGroup::setF32(const std::string& name, F32 val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 
 void LLControlGroup::setU32(const std::string& name, U32 val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 
 void LLControlGroup::setString(const std::string& name, const std::string &val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 
 void LLControlGroup::setVector3(const std::string& name, const LLVector3 &val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 void LLControlGroup::setVector3d(const std::string& name, const LLVector3d &val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 void LLControlGroup::setQuaternion(const std::string& name, const LLQuaternion &val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 void LLControlGroup::setRect(const std::string& name, const LLRect &val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 void LLControlGroup::setColor4(const std::string& name, const LLColor4 &val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 void LLControlGroup::setLLSD(const std::string& name, const LLSD& val)
 {
-	set(name, val);
+    set(name, val);
 }
 
 void LLControlGroup::setUntypedValue(const std::string& name, const LLSD& val, bool saved_value)
 {
-	if (name.empty())
-	{
-		return;
-	}
+    if (name.empty())
+    {
+        return;
+    }
+
+    LLControlVariable* control = getControl(name);
 
-	LLControlVariable* control = getControl(name);
-	
-	if (control)
-	{
-		control->setValue(val, saved_value);
-	}
-	else
-	{
-		CONTROL_ERRS << "Invalid control " << name << LL_ENDL;
-	}
+    if (control)
+    {
+        control->setValue(val, saved_value);
+    }
+    else
+    {
+        CONTROL_ERRS << "Invalid control " << name << LL_ENDL;
+    }
 }
 
 
@@ -757,388 +757,388 @@ void LLControlGroup::setUntypedValue(const std::string& name, const LLSD& val, b
 // Returns number of controls loaded, so 0 if failure
 U32 LLControlGroup::loadFromFileLegacy(const std::string& filename, BOOL require_declaration, eControlType declare_as)
 {
-	std::string name;
-
-	LLXmlTree xml_controls;
-
-	if (!xml_controls.parseFile(filename))
-	{
-		LL_WARNS("Settings") << "Unable to open control file " << filename << LL_ENDL;
-		return 0;
-	}
-
-	LLXmlTreeNode* rootp = xml_controls.getRoot();
-	if (!rootp || !rootp->hasAttribute("version"))
-	{
-		LL_WARNS("Settings") << "No valid settings header found in control file " << filename << LL_ENDL;
-		return 0;
-	}
-
-	U32		validitems = 0;
-	S32 version;
-	
-	rootp->getAttributeS32("version", version);
-
-	// Check file version
-	if (version != CURRENT_VERSION)
-	{
-		LL_INFOS("Settings") << filename << " does not appear to be a version " << CURRENT_VERSION << " controls file" << LL_ENDL;
-		return 0;
-	}
-
-	LLXmlTreeNode* child_nodep = rootp->getFirstChild();
-	while(child_nodep)
-	{
-		name = child_nodep->getName();		
-		
-		BOOL declared = controlExists(name);
-
-		if (require_declaration && !declared)
-		{
-			// Declaration required, but this name not declared.
-			// Complain about non-empty names.
-			if (!name.empty())
-			{
-				//read in to end of line
-				LL_WARNS("Settings") << "LLControlGroup::loadFromFile() : Trying to set \"" << name << "\", setting doesn't exist." << LL_ENDL;
-			}
-			child_nodep = rootp->getNextChild();
-			continue;
-		}
-
-		// Got an item.  Load it up.
-		// If not declared, assume it's a string
-		if (!declared)
-		{
-			switch(declare_as)
-			{
-			case TYPE_COL4:
-				declareColor4(name, LLColor4::white, LLStringUtil::null, LLControlVariable::PERSIST_NO);
-				break;
-			case TYPE_STRING:
-			default:
-				declareString(name, LLStringUtil::null, LLStringUtil::null, LLControlVariable::PERSIST_NO);
-				break;
-			}
-		}
-
-		// Control name has been declared in code.
-		LLControlVariable *control = getControl(name);
-
-		llassert(control);
-		
-		switch(control->mType)
-		{
-		case TYPE_F32:
-			{
-				F32 initial = 0.f;
-
-				child_nodep->getAttributeF32("value", initial);
-
-				control->set(initial);
-				validitems++;
-			}
-			break;
-		case TYPE_S32:
-			{
-				S32 initial = 0;
-
-				child_nodep->getAttributeS32("value", initial);
-
-				control->set(initial);
-				validitems++;
-			}
-			break;
-		case TYPE_U32:
-			{
-				U32 initial = 0;
-				child_nodep->getAttributeU32("value", initial);
-				control->set((LLSD::Integer) initial);
-				validitems++;
-			}
-			break;
-		case TYPE_BOOLEAN:
-			{
-				BOOL initial = FALSE;
-
-				child_nodep->getAttributeBOOL("value", initial);
-				control->set(initial);
-
-				validitems++;
-			}
-			break;
-		case TYPE_STRING:
-			{
-				std::string string;
-				child_nodep->getAttributeString("value", string);
-				control->set(string);
-				validitems++;
-			}
-			break;
-		case TYPE_VEC3:
-			{
-				LLVector3 vector;
-
-				child_nodep->getAttributeVector3("value", vector);
-				control->set(vector.getValue());
-				validitems++;
-			}
-			break;
-		case TYPE_VEC3D:
-			{
-				LLVector3d vector;
-
-				child_nodep->getAttributeVector3d("value", vector);
-
-				control->set(vector.getValue());
-				validitems++;
-			}
-			break;
-		case TYPE_QUAT:
-			{
-				LLQuaternion quat;
-
-				child_nodep->getAttributeQuat("value", quat);
-
-				control->set(quat.getValue());
-				validitems++;
-			}
-			break;
-		case TYPE_RECT:
-			{
-				//RN: hack to support reading rectangles from a string
-				std::string rect_string;
-
-				child_nodep->getAttributeString("value", rect_string);
-				std::istringstream istream(rect_string);
-				S32 left, bottom, width, height;
-
-				istream >> left >> bottom >> width >> height;
-
-				LLRect rect;
-				rect.setOriginAndSize(left, bottom, width, height);
-
-				control->set(rect.getValue());
-				validitems++;
-			}
-			break;
-		case TYPE_COL4:
-			{
-				LLColor4 color;
-				
-				child_nodep->getAttributeColor4("value", color);
-				control->set(color.getValue());
-				validitems++;
-			}
-			break;
-		case TYPE_COL3:
-			{
-				LLVector3 color;
-				
-				child_nodep->getAttributeVector3("value", color);
-				control->set(LLColor3(color.mV).getValue());
-				validitems++;
-			}
-			break;
-
-		default:
-		  break;
-
-		}
-	
-		child_nodep = rootp->getNextChild();
-	}
-
-	return validitems;
+    std::string name;
+
+    LLXmlTree xml_controls;
+
+    if (!xml_controls.parseFile(filename))
+    {
+        LL_WARNS("Settings") << "Unable to open control file " << filename << LL_ENDL;
+        return 0;
+    }
+
+    LLXmlTreeNode* rootp = xml_controls.getRoot();
+    if (!rootp || !rootp->hasAttribute("version"))
+    {
+        LL_WARNS("Settings") << "No valid settings header found in control file " << filename << LL_ENDL;
+        return 0;
+    }
+
+    U32     validitems = 0;
+    S32 version;
+
+    rootp->getAttributeS32("version", version);
+
+    // Check file version
+    if (version != CURRENT_VERSION)
+    {
+        LL_INFOS("Settings") << filename << " does not appear to be a version " << CURRENT_VERSION << " controls file" << LL_ENDL;
+        return 0;
+    }
+
+    LLXmlTreeNode* child_nodep = rootp->getFirstChild();
+    while(child_nodep)
+    {
+        name = child_nodep->getName();
+
+        BOOL declared = controlExists(name);
+
+        if (require_declaration && !declared)
+        {
+            // Declaration required, but this name not declared.
+            // Complain about non-empty names.
+            if (!name.empty())
+            {
+                //read in to end of line
+                LL_WARNS("Settings") << "LLControlGroup::loadFromFile() : Trying to set \"" << name << "\", setting doesn't exist." << LL_ENDL;
+            }
+            child_nodep = rootp->getNextChild();
+            continue;
+        }
+
+        // Got an item.  Load it up.
+        // If not declared, assume it's a string
+        if (!declared)
+        {
+            switch(declare_as)
+            {
+            case TYPE_COL4:
+                declareColor4(name, LLColor4::white, LLStringUtil::null, LLControlVariable::PERSIST_NO);
+                break;
+            case TYPE_STRING:
+            default:
+                declareString(name, LLStringUtil::null, LLStringUtil::null, LLControlVariable::PERSIST_NO);
+                break;
+            }
+        }
+
+        // Control name has been declared in code.
+        LLControlVariable *control = getControl(name);
+
+        llassert(control);
+
+        switch(control->mType)
+        {
+        case TYPE_F32:
+            {
+                F32 initial = 0.f;
+
+                child_nodep->getAttributeF32("value", initial);
+
+                control->set(initial);
+                validitems++;
+            }
+            break;
+        case TYPE_S32:
+            {
+                S32 initial = 0;
+
+                child_nodep->getAttributeS32("value", initial);
+
+                control->set(initial);
+                validitems++;
+            }
+            break;
+        case TYPE_U32:
+            {
+                U32 initial = 0;
+                child_nodep->getAttributeU32("value", initial);
+                control->set((LLSD::Integer) initial);
+                validitems++;
+            }
+            break;
+        case TYPE_BOOLEAN:
+            {
+                BOOL initial = FALSE;
+
+                child_nodep->getAttributeBOOL("value", initial);
+                control->set(initial);
+
+                validitems++;
+            }
+            break;
+        case TYPE_STRING:
+            {
+                std::string string;
+                child_nodep->getAttributeString("value", string);
+                control->set(string);
+                validitems++;
+            }
+            break;
+        case TYPE_VEC3:
+            {
+                LLVector3 vector;
+
+                child_nodep->getAttributeVector3("value", vector);
+                control->set(vector.getValue());
+                validitems++;
+            }
+            break;
+        case TYPE_VEC3D:
+            {
+                LLVector3d vector;
+
+                child_nodep->getAttributeVector3d("value", vector);
+
+                control->set(vector.getValue());
+                validitems++;
+            }
+            break;
+        case TYPE_QUAT:
+            {
+                LLQuaternion quat;
+
+                child_nodep->getAttributeQuat("value", quat);
+
+                control->set(quat.getValue());
+                validitems++;
+            }
+            break;
+        case TYPE_RECT:
+            {
+                //RN: hack to support reading rectangles from a string
+                std::string rect_string;
+
+                child_nodep->getAttributeString("value", rect_string);
+                std::istringstream istream(rect_string);
+                S32 left, bottom, width, height;
+
+                istream >> left >> bottom >> width >> height;
+
+                LLRect rect;
+                rect.setOriginAndSize(left, bottom, width, height);
+
+                control->set(rect.getValue());
+                validitems++;
+            }
+            break;
+        case TYPE_COL4:
+            {
+                LLColor4 color;
+
+                child_nodep->getAttributeColor4("value", color);
+                control->set(color.getValue());
+                validitems++;
+            }
+            break;
+        case TYPE_COL3:
+            {
+                LLVector3 color;
+
+                child_nodep->getAttributeVector3("value", color);
+                control->set(LLColor3(color.mV).getValue());
+                validitems++;
+            }
+            break;
+
+        default:
+          break;
+
+        }
+
+        child_nodep = rootp->getNextChild();
+    }
+
+    return validitems;
 }
 
 U32 LLControlGroup::saveToFile(const std::string& filename, BOOL nondefault_only)
 {
-	LLSD settings;
-	int num_saved = 0;
-	for (ctrl_name_table_t::iterator iter = mNameTable.begin();
-		 iter != mNameTable.end(); iter++)
-	{
-		LLControlVariable* control = iter->second;
-		if (!control)
-		{
-			LL_WARNS("Settings") << "Tried to save invalid control: " << iter->first << LL_ENDL;
-		}
-		else if( control->shouldSave(nondefault_only) )
-		{
-			settings[iter->first]["Type"] = typeEnumToString(control->type());
-			settings[iter->first]["Comment"] = control->getComment();
-			settings[iter->first]["Value"] = control->getSaveValue();
-			++num_saved;
-		}
-	}
-	llofstream file;
-	file.open(filename.c_str());
-	if (file.is_open())
-	{
-		LLSDSerialize::toPrettyXML(settings, file);
-		file.close();
-		LL_INFOS("Settings") << "Saved to " << filename << LL_ENDL;
-	}
-	else
-	{
+    LLSD settings;
+    int num_saved = 0;
+    for (ctrl_name_table_t::iterator iter = mNameTable.begin();
+         iter != mNameTable.end(); iter++)
+    {
+        LLControlVariable* control = iter->second;
+        if (!control)
+        {
+            LL_WARNS("Settings") << "Tried to save invalid control: " << iter->first << LL_ENDL;
+        }
+        else if( control->shouldSave(nondefault_only) )
+        {
+            settings[iter->first]["Type"] = typeEnumToString(control->type());
+            settings[iter->first]["Comment"] = control->getComment();
+            settings[iter->first]["Value"] = control->getSaveValue();
+            ++num_saved;
+        }
+    }
+    llofstream file;
+    file.open(filename.c_str());
+    if (file.is_open())
+    {
+        LLSDSerialize::toPrettyXML(settings, file);
+        file.close();
+        LL_INFOS("Settings") << "Saved to " << filename << LL_ENDL;
+    }
+    else
+    {
         // This is a warning because sometime we want to use settings files which can't be written...
-		LL_WARNS("Settings") << "Unable to open settings file: " << filename << LL_ENDL;
-		return 0;
-	}
-	return num_saved;
+        LL_WARNS("Settings") << "Unable to open settings file: " << filename << LL_ENDL;
+        return 0;
+    }
+    return num_saved;
 }
 
 U32 LLControlGroup::loadFromFile(const std::string& filename, bool set_default_values, bool save_values)
 {
-	LLSD settings;
-	llifstream infile;
-	infile.open(filename.c_str());
-	if(!infile.is_open())
-	{
-		LL_WARNS("Settings") << "Cannot find file " << filename << " to load." << LL_ENDL;
-		return 0;
-	}
-
-	if (LLSDParser::PARSE_FAILURE == LLSDSerialize::fromXML(settings, infile))
-	{
-		infile.close();
-		LL_WARNS("Settings") << "Unable to parse LLSD control file " << filename << ". Trying Legacy Method." << LL_ENDL;
-		return loadFromFileLegacy(filename, TRUE, TYPE_STRING);
-	}
-
-	U32	validitems = 0;
-	bool hidefromsettingseditor = false;
-	
-	for(LLSD::map_const_iterator itr = settings.beginMap(); itr != settings.endMap(); ++itr)
-	{
-		LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT;
-		std::string const & name = itr->first;
-		LLSD const & control_map = itr->second;
-		
-		if(control_map.has("Persist")) 
-		{
-			persist = control_map["Persist"].asInteger()?
-					  LLControlVariable::PERSIST_NONDFT : LLControlVariable::PERSIST_NO;
-		}
-		
-		// Sometimes we want to use the settings system to provide cheap persistence, but we
-		// don't want the settings themselves to be easily manipulated in the UI because 
-		// doing so can cause support problems. So we have this option:
-		if(control_map.has("HideFromEditor"))
-		{
-			hidefromsettingseditor = control_map["HideFromEditor"].asInteger();
-		}
-		else
-		{
-			hidefromsettingseditor = false;
-		}
-		
-		// If the control exists just set the value from the input file.
-		LLControlVariable* existing_control = getControl(name);
-		if(existing_control)
-		{
-			// set_default_values is true when we're loading the initial,
-			// immutable files from app_settings, e.g. settings.xml.
-			if(set_default_values)
-			{
-				// Override all previously set properties of this control.
-				// ... except for type. The types must match.
-				eControlType new_type = typeStringToEnum(control_map["Type"].asString());
-				if(existing_control->isType(new_type))
-				{
-					existing_control->setDefaultValue(control_map["Value"]);
-					existing_control->setPersist(persist);
-					existing_control->setHiddenFromSettingsEditor(hidefromsettingseditor);
-					existing_control->setComment(control_map["Comment"].asString());
-				}
-				else
-				{
-					LL_ERRS() << "Mismatched type of control variable '"
-						   << name << "' found while loading '"
-						   << filename << "'." << LL_ENDL;
-				}
-			}
-			else if(existing_control->isPersisted())
-			{
-				// save_values is specifically false for (e.g.)
-				// SessionSettingsFile and UserSessionSettingsFile -- in other
-				// words, for a file that's supposed to be transient.
-				existing_control->setValue(control_map["Value"], save_values);
-			}
-			// *NOTE: If not persisted and not setting defaults, 
-			// the value should not get loaded.
-		}
-		else
-		{
-			// We've never seen this control before. Either we're loading up
-			// the initial set of default settings files (set_default_values)
-			// -- or we're loading user settings last saved by a viewer that
-			// supports a superset of the variables we know.
-			// CHOP-962: if we're loading an unrecognized user setting, make
-			// sure we save it later. If you try an experimental viewer, tweak
-			// a new setting, briefly revert to an old viewer, then return to
-			// the new one, we don't want the old viewer to discard the
-			// setting you changed.
-			if (! set_default_values)
-			{
-				// Using PERSIST_ALWAYS insists that saveToFile() (which calls
-				// LLControlVariable::shouldSave()) must save this control
-				// variable regardless of its value. We can safely set this
-				// LLControlVariable persistent because the 'persistent' flag
-				// is not itself persisted!
-				persist = LLControlVariable::PERSIST_ALWAYS;
-				// We want to mention unrecognized user settings variables
-				// (e.g. from a newer version of the viewer) in the log. But
-				// we also arrive here for Boolean variables generated by
-				// the notifications subsystem when the user checks "Don't
-				// show me this again." These aren't declared in settings.xml;
-				// they're actually named for the notification they suppress.
-				// We don't want to mention those. Apologies, this is a bit of
-				// a hack: we happen to know that user settings go into an
-				// LLControlGroup whose name is "Global".
-				if (getKey() == "Global")
-				{
-					LL_INFOS("LLControlGroup") << "preserving unrecognized " << getKey()
-											   << " settings variable " << name << LL_ENDL;
-				}
-			}
-
-			declareControl(name, 
-						   typeStringToEnum(control_map["Type"].asString()), 
-						   control_map["Value"], 
-						   control_map["Comment"].asString(), 
-						   persist,
-						   hidefromsettingseditor
-						   );
-		}
-
-		++validitems;
-	}
-
-	LL_DEBUGS("Settings") << "Loaded " << validitems << " settings from " << filename << LL_ENDL;
-	return validitems;
+    LLSD settings;
+    llifstream infile;
+    infile.open(filename.c_str());
+    if(!infile.is_open())
+    {
+        LL_WARNS("Settings") << "Cannot find file " << filename << " to load." << LL_ENDL;
+        return 0;
+    }
+
+    if (LLSDParser::PARSE_FAILURE == LLSDSerialize::fromXML(settings, infile))
+    {
+        infile.close();
+        LL_WARNS("Settings") << "Unable to parse LLSD control file " << filename << ". Trying Legacy Method." << LL_ENDL;
+        return loadFromFileLegacy(filename, TRUE, TYPE_STRING);
+    }
+
+    U32 validitems = 0;
+    bool hidefromsettingseditor = false;
+
+    for(LLSD::map_const_iterator itr = settings.beginMap(); itr != settings.endMap(); ++itr)
+    {
+        LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT;
+        std::string const & name = itr->first;
+        LLSD const & control_map = itr->second;
+
+        if(control_map.has("Persist"))
+        {
+            persist = control_map["Persist"].asInteger()?
+                      LLControlVariable::PERSIST_NONDFT : LLControlVariable::PERSIST_NO;
+        }
+
+        // Sometimes we want to use the settings system to provide cheap persistence, but we
+        // don't want the settings themselves to be easily manipulated in the UI because
+        // doing so can cause support problems. So we have this option:
+        if(control_map.has("HideFromEditor"))
+        {
+            hidefromsettingseditor = control_map["HideFromEditor"].asInteger();
+        }
+        else
+        {
+            hidefromsettingseditor = false;
+        }
+
+        // If the control exists just set the value from the input file.
+        LLControlVariable* existing_control = getControl(name);
+        if(existing_control)
+        {
+            // set_default_values is true when we're loading the initial,
+            // immutable files from app_settings, e.g. settings.xml.
+            if(set_default_values)
+            {
+                // Override all previously set properties of this control.
+                // ... except for type. The types must match.
+                eControlType new_type = typeStringToEnum(control_map["Type"].asString());
+                if(existing_control->isType(new_type))
+                {
+                    existing_control->setDefaultValue(control_map["Value"]);
+                    existing_control->setPersist(persist);
+                    existing_control->setHiddenFromSettingsEditor(hidefromsettingseditor);
+                    existing_control->setComment(control_map["Comment"].asString());
+                }
+                else
+                {
+                    LL_ERRS() << "Mismatched type of control variable '"
+                           << name << "' found while loading '"
+                           << filename << "'." << LL_ENDL;
+                }
+            }
+            else if(existing_control->isPersisted())
+            {
+                // save_values is specifically false for (e.g.)
+                // SessionSettingsFile and UserSessionSettingsFile -- in other
+                // words, for a file that's supposed to be transient.
+                existing_control->setValue(control_map["Value"], save_values);
+            }
+            // *NOTE: If not persisted and not setting defaults,
+            // the value should not get loaded.
+        }
+        else
+        {
+            // We've never seen this control before. Either we're loading up
+            // the initial set of default settings files (set_default_values)
+            // -- or we're loading user settings last saved by a viewer that
+            // supports a superset of the variables we know.
+            // CHOP-962: if we're loading an unrecognized user setting, make
+            // sure we save it later. If you try an experimental viewer, tweak
+            // a new setting, briefly revert to an old viewer, then return to
+            // the new one, we don't want the old viewer to discard the
+            // setting you changed.
+            if (! set_default_values)
+            {
+                // Using PERSIST_ALWAYS insists that saveToFile() (which calls
+                // LLControlVariable::shouldSave()) must save this control
+                // variable regardless of its value. We can safely set this
+                // LLControlVariable persistent because the 'persistent' flag
+                // is not itself persisted!
+                persist = LLControlVariable::PERSIST_ALWAYS;
+                // We want to mention unrecognized user settings variables
+                // (e.g. from a newer version of the viewer) in the log. But
+                // we also arrive here for Boolean variables generated by
+                // the notifications subsystem when the user checks "Don't
+                // show me this again." These aren't declared in settings.xml;
+                // they're actually named for the notification they suppress.
+                // We don't want to mention those. Apologies, this is a bit of
+                // a hack: we happen to know that user settings go into an
+                // LLControlGroup whose name is "Global".
+                if (getKey() == "Global")
+                {
+                    LL_INFOS("LLControlGroup") << "preserving unrecognized " << getKey()
+                                               << " settings variable " << name << LL_ENDL;
+                }
+            }
+
+            declareControl(name,
+                           typeStringToEnum(control_map["Type"].asString()),
+                           control_map["Value"],
+                           control_map["Comment"].asString(),
+                           persist,
+                           hidefromsettingseditor
+                           );
+        }
+
+        ++validitems;
+    }
+
+    LL_DEBUGS("Settings") << "Loaded " << validitems << " settings from " << filename << LL_ENDL;
+    return validitems;
 }
 
 void LLControlGroup::resetToDefaults()
 {
-	ctrl_name_table_t::iterator control_iter;
-	for (control_iter = mNameTable.begin();
-		control_iter != mNameTable.end();
-		++control_iter)
-	{
-		LLControlVariable* control = (*control_iter).second;
-		control->resetToDefault();
-	}
+    ctrl_name_table_t::iterator control_iter;
+    for (control_iter = mNameTable.begin();
+        control_iter != mNameTable.end();
+        ++control_iter)
+    {
+        LLControlVariable* control = (*control_iter).second;
+        control->resetToDefault();
+    }
 }
 
 void LLControlGroup::applyToAll(ApplyFunctor* func)
 {
-	for (ctrl_name_table_t::iterator iter = mNameTable.begin();
-		 iter != mNameTable.end(); iter++)
-	{
-		func->apply(iter->first, iter->second);
-	}
+    for (ctrl_name_table_t::iterator iter = mNameTable.begin();
+         iter != mNameTable.end(); iter++)
+    {
+        func->apply(iter->first, iter->second);
+    }
 }
 
 //============================================================================
@@ -1146,335 +1146,335 @@ void LLControlGroup::applyToAll(ApplyFunctor* func)
 #ifdef TEST_HARNESS
 void main()
 {
-	F32_CONTROL foo, getfoo;
+    F32_CONTROL foo, getfoo;
+
+    S32_CONTROL bar, getbar;
 
-	S32_CONTROL bar, getbar;
-	
-	BOOL_CONTROL baz;
+    BOOL_CONTROL baz;
 
-	U32 count = gGlobals.loadFromFile("controls.ini");
-	LL_INFOS("Settings") << "Loaded " << count << " controls" << LL_ENDL;
+    U32 count = gGlobals.loadFromFile("controls.ini");
+    LL_INFOS("Settings") << "Loaded " << count << " controls" << LL_ENDL;
 
-	// test insertion
-	foo = new LLControlVariable<F32>("gFoo", 5.f, 1.f, 20.f);
-	gGlobals.addEntry("gFoo", foo);
+    // test insertion
+    foo = new LLControlVariable<F32>("gFoo", 5.f, 1.f, 20.f);
+    gGlobals.addEntry("gFoo", foo);
 
-	bar = new LLControlVariable<S32>("gBar", 10, 2, 22);
-	gGlobals.addEntry("gBar", bar);
+    bar = new LLControlVariable<S32>("gBar", 10, 2, 22);
+    gGlobals.addEntry("gBar", bar);
 
-	baz = new LLControlVariable<BOOL>("gBaz", FALSE);
-	gGlobals.addEntry("gBaz", baz);
+    baz = new LLControlVariable<BOOL>("gBaz", FALSE);
+    gGlobals.addEntry("gBaz", baz);
 
-	// test retrieval
-	getfoo = (LLControlVariable<F32>*) gGlobals.resolveName("gFoo");
-	getfoo->dump();
+    // test retrieval
+    getfoo = (LLControlVariable<F32>*) gGlobals.resolveName("gFoo");
+    getfoo->dump();
 
-	getbar = (S32_CONTROL) gGlobals.resolveName("gBar");
-	getbar->dump();
+    getbar = (S32_CONTROL) gGlobals.resolveName("gBar");
+    getbar->dump();
 
-	// change data
-	getfoo->set(10.f);
-	getfoo->dump();
+    // change data
+    getfoo->set(10.f);
+    getfoo->dump();
 
-	// Failure modes
+    // Failure modes
 
-	// ...min > max
-	// badfoo = new LLControlVariable<F32>("gFoo2", 100.f, 20.f, 5.f);
+    // ...min > max
+    // badfoo = new LLControlVariable<F32>("gFoo2", 100.f, 20.f, 5.f);
 
-	// ...initial > max
-	// badbar = new LLControlVariable<S32>("gBar2", 10, 20, 100000);
+    // ...initial > max
+    // badbar = new LLControlVariable<S32>("gBar2", 10, 20, 100000);
 
-	// ...misspelled name
-	// getfoo = (F32_CONTROL) gGlobals.resolveName("fooMisspelled");
-	// getfoo->dump();
+    // ...misspelled name
+    // getfoo = (F32_CONTROL) gGlobals.resolveName("fooMisspelled");
+    // getfoo->dump();
 
-	// ...invalid data type
-	getfoo = (F32_CONTROL) gGlobals.resolveName("gFoo");
-	getfoo->set(TRUE);
-	getfoo->dump();
+    // ...invalid data type
+    getfoo = (F32_CONTROL) gGlobals.resolveName("gFoo");
+    getfoo->set(TRUE);
+    getfoo->dump();
 
-	// ...out of range data
-	// getfoo->set(100000000.f);
-	// getfoo->dump();
+    // ...out of range data
+    // getfoo->set(100000000.f);
+    // getfoo->dump();
 
-	// Clean Up
-	delete foo;
-	delete bar;
-	delete baz;
+    // Clean Up
+    delete foo;
+    delete bar;
+    delete baz;
 }
 #endif
 
 
-template <> eControlType get_control_type<U32>() 
-{ 
-	return TYPE_U32; 
+template <> eControlType get_control_type<U32>()
+{
+    return TYPE_U32;
 }
 
-template <> eControlType get_control_type<S32>() 
-{ 
-	return TYPE_S32; 
+template <> eControlType get_control_type<S32>()
+{
+    return TYPE_S32;
 }
 
-template <> eControlType get_control_type<F32>() 
-{ 
-	return TYPE_F32; 
+template <> eControlType get_control_type<F32>()
+{
+    return TYPE_F32;
 }
 
-template <> eControlType get_control_type<bool> () 
-{ 
-	return TYPE_BOOLEAN; 
+template <> eControlType get_control_type<bool> ()
+{
+    return TYPE_BOOLEAN;
 }
 /*
 // Yay BOOL, its really an S32.
-template <> eControlType get_control_type<BOOL> () 
-{ 
-	return TYPE_BOOLEAN; 
+template <> eControlType get_control_type<BOOL> ()
+{
+    return TYPE_BOOLEAN;
 }
 */
-template <> eControlType get_control_type<std::string>() 
-{ 
-	return TYPE_STRING; 
+template <> eControlType get_control_type<std::string>()
+{
+    return TYPE_STRING;
 }
 
-template <> eControlType get_control_type<LLVector3>() 
-{ 
-	return TYPE_VEC3; 
+template <> eControlType get_control_type<LLVector3>()
+{
+    return TYPE_VEC3;
 }
 
-template <> eControlType get_control_type<LLVector3d>() 
-{ 
-	return TYPE_VEC3D; 
+template <> eControlType get_control_type<LLVector3d>()
+{
+    return TYPE_VEC3D;
 }
 
 template <> eControlType get_control_type<LLQuaternion>()
 {
-	return TYPE_QUAT;
+    return TYPE_QUAT;
 }
 
-template <> eControlType get_control_type<LLRect>() 
-{ 
-	return TYPE_RECT; 
+template <> eControlType get_control_type<LLRect>()
+{
+    return TYPE_RECT;
 }
 
-template <> eControlType get_control_type<LLColor4>() 
-{ 
-	return TYPE_COL4; 
+template <> eControlType get_control_type<LLColor4>()
+{
+    return TYPE_COL4;
 }
 
-template <> eControlType get_control_type<LLColor3>() 
-{ 
-	return TYPE_COL3; 
+template <> eControlType get_control_type<LLColor3>()
+{
+    return TYPE_COL3;
 }
 
-template <> eControlType get_control_type<LLSD>() 
-{ 
-	return TYPE_LLSD; 
+template <> eControlType get_control_type<LLSD>()
+{
+    return TYPE_LLSD;
 }
 
 
-template <> LLSD convert_to_llsd<U32>(const U32& in) 
-{ 
-	return (LLSD::Integer)in; 
+template <> LLSD convert_to_llsd<U32>(const U32& in)
+{
+    return (LLSD::Integer)in;
 }
 
-template <> LLSD convert_to_llsd<LLVector3>(const LLVector3& in) 
-{ 
-	return in.getValue(); 
+template <> LLSD convert_to_llsd<LLVector3>(const LLVector3& in)
+{
+    return in.getValue();
 }
 
-template <> LLSD convert_to_llsd<LLVector3d>(const LLVector3d& in) 
-{ 
-	return in.getValue(); 
+template <> LLSD convert_to_llsd<LLVector3d>(const LLVector3d& in)
+{
+    return in.getValue();
 }
 template <> LLSD convert_to_llsd<LLQuaternion>(const LLQuaternion& in)
 {
-	return in.getValue();
+    return in.getValue();
 }
 
-template <> LLSD convert_to_llsd<LLRect>(const LLRect& in) 
-{ 
-	return in.getValue(); 
+template <> LLSD convert_to_llsd<LLRect>(const LLRect& in)
+{
+    return in.getValue();
 }
 
-template <> LLSD convert_to_llsd<LLColor4>(const LLColor4& in) 
-{ 
-	return in.getValue(); 
+template <> LLSD convert_to_llsd<LLColor4>(const LLColor4& in)
+{
+    return in.getValue();
 }
 
-template <> LLSD convert_to_llsd<LLColor3>(const LLColor3& in) 
-{ 
-	return in.getValue(); 
+template <> LLSD convert_to_llsd<LLColor3>(const LLColor3& in)
+{
+    return in.getValue();
 }
 
-template <> LLSD convert_to_llsd<LLColor4U>(const LLColor4U& in) 
-{ 
-	return in.getValue();
+template <> LLSD convert_to_llsd<LLColor4U>(const LLColor4U& in)
+{
+    return in.getValue();
 }
 
 
 template<>
 bool convert_from_llsd<bool>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_BOOLEAN)
-		return sd.asBoolean();
-	else
-	{
-		CONTROL_ERRS << "Invalid BOOL value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return FALSE;
-	}
+    if (type == TYPE_BOOLEAN)
+        return sd.asBoolean();
+    else
+    {
+        CONTROL_ERRS << "Invalid BOOL value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return FALSE;
+    }
 }
 
 template<>
 S32 convert_from_llsd<S32>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_S32)
-		return sd.asInteger();
-	else
-	{
-		CONTROL_ERRS << "Invalid S32 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return 0;
-	}
+    if (type == TYPE_S32)
+        return sd.asInteger();
+    else
+    {
+        CONTROL_ERRS << "Invalid S32 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return 0;
+    }
 }
 
 template<>
 U32 convert_from_llsd<U32>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_U32)	
-		return sd.asInteger();
-	else
-	{
-		CONTROL_ERRS << "Invalid U32 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return 0;
-	}
+    if (type == TYPE_U32)
+        return sd.asInteger();
+    else
+    {
+        CONTROL_ERRS << "Invalid U32 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return 0;
+    }
 }
 
 template<>
 F32 convert_from_llsd<F32>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_F32)
-		return (F32) sd.asReal();
-	else
-	{
-		CONTROL_ERRS << "Invalid F32 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return 0.0f;
-	}
+    if (type == TYPE_F32)
+        return (F32) sd.asReal();
+    else
+    {
+        CONTROL_ERRS << "Invalid F32 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return 0.0f;
+    }
 }
 
 template<>
 std::string convert_from_llsd<std::string>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_STRING)
-		return sd.asString();
-	else
-	{
-		CONTROL_ERRS << "Invalid string value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return LLStringUtil::null;
-	}
+    if (type == TYPE_STRING)
+        return sd.asString();
+    else
+    {
+        CONTROL_ERRS << "Invalid string value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return LLStringUtil::null;
+    }
 }
 
 template<>
 LLWString convert_from_llsd<LLWString>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	return utf8str_to_wstring(convert_from_llsd<std::string>(sd, type, control_name));
+    return utf8str_to_wstring(convert_from_llsd<std::string>(sd, type, control_name));
 }
 
 template<>
 LLVector3 convert_from_llsd<LLVector3>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_VEC3)
-		return (LLVector3)sd;
-	else
-	{
-		CONTROL_ERRS << "Invalid LLVector3 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return LLVector3::zero;
-	}
+    if (type == TYPE_VEC3)
+        return (LLVector3)sd;
+    else
+    {
+        CONTROL_ERRS << "Invalid LLVector3 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return LLVector3::zero;
+    }
 }
 
 template<>
 LLVector3d convert_from_llsd<LLVector3d>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_VEC3D)
-		return (LLVector3d)sd;
-	else
-	{
-		CONTROL_ERRS << "Invalid LLVector3d value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return LLVector3d::zero;
-	}
+    if (type == TYPE_VEC3D)
+        return (LLVector3d)sd;
+    else
+    {
+        CONTROL_ERRS << "Invalid LLVector3d value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return LLVector3d::zero;
+    }
 }
 
 template<>
 LLQuaternion convert_from_llsd<LLQuaternion>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_QUAT)
-		return (LLQuaternion)sd;
-	else
-	{
-		CONTROL_ERRS << "Invalid LLQuaternion value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return LLQuaternion();
-	}
+    if (type == TYPE_QUAT)
+        return (LLQuaternion)sd;
+    else
+    {
+        CONTROL_ERRS << "Invalid LLQuaternion value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return LLQuaternion();
+    }
 }
 
 template<>
 LLRect convert_from_llsd<LLRect>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_RECT)
-		return LLRect(sd);
-	else
-	{
-		CONTROL_ERRS << "Invalid rect value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return LLRect::null;
-	}
+    if (type == TYPE_RECT)
+        return LLRect(sd);
+    else
+    {
+        CONTROL_ERRS << "Invalid rect value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return LLRect::null;
+    }
 }
 
 
 template<>
 LLColor4 convert_from_llsd<LLColor4>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_COL4)
-	{
-		LLColor4 color(sd);
-		if (color.mV[VRED] < 0.f || color.mV[VRED] > 1.f)
-		{
-			LL_WARNS("Settings") << "Color " << control_name << " red value out of range: " << color << LL_ENDL;
-		}
-		else if (color.mV[VGREEN] < 0.f || color.mV[VGREEN] > 1.f)
-		{
-			LL_WARNS("Settings") << "Color " << control_name << " green value out of range: " << color << LL_ENDL;
-		}
-		else if (color.mV[VBLUE] < 0.f || color.mV[VBLUE] > 1.f)
-		{
-			LL_WARNS("Settings") << "Color " << control_name << " blue value out of range: " << color << LL_ENDL;
-		}
-		else if (color.mV[VALPHA] < 0.f || color.mV[VALPHA] > 1.f)
-		{
-			LL_WARNS("Settings") << "Color " << control_name << " alpha value out of range: " << color << LL_ENDL;
-		}
-
-		return LLColor4(sd);
-	}
-	else
-	{
-		CONTROL_ERRS << "Control " << control_name << " not a color" << LL_ENDL;
-		return LLColor4::white;
-	}
+    if (type == TYPE_COL4)
+    {
+        LLColor4 color(sd);
+        if (color.mV[VRED] < 0.f || color.mV[VRED] > 1.f)
+        {
+            LL_WARNS("Settings") << "Color " << control_name << " red value out of range: " << color << LL_ENDL;
+        }
+        else if (color.mV[VGREEN] < 0.f || color.mV[VGREEN] > 1.f)
+        {
+            LL_WARNS("Settings") << "Color " << control_name << " green value out of range: " << color << LL_ENDL;
+        }
+        else if (color.mV[VBLUE] < 0.f || color.mV[VBLUE] > 1.f)
+        {
+            LL_WARNS("Settings") << "Color " << control_name << " blue value out of range: " << color << LL_ENDL;
+        }
+        else if (color.mV[VALPHA] < 0.f || color.mV[VALPHA] > 1.f)
+        {
+            LL_WARNS("Settings") << "Color " << control_name << " alpha value out of range: " << color << LL_ENDL;
+        }
+
+        return LLColor4(sd);
+    }
+    else
+    {
+        CONTROL_ERRS << "Control " << control_name << " not a color" << LL_ENDL;
+        return LLColor4::white;
+    }
 }
 
 template<>
 LLColor3 convert_from_llsd<LLColor3>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	if (type == TYPE_COL3)
-		return sd;
-	else
-	{
-		CONTROL_ERRS << "Invalid LLColor3 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
-		return LLColor3::white;
-	}
+    if (type == TYPE_COL3)
+        return sd;
+    else
+    {
+        CONTROL_ERRS << "Invalid LLColor3 value for " << control_name << ": " << LLControlGroup::typeEnumToString(type) << " " << sd << LL_ENDL;
+        return LLColor3::white;
+    }
 }
 
 template<>
 LLSD convert_from_llsd<LLSD>(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	return sd;
+    return sd;
 }
 
 
@@ -1502,21 +1502,21 @@ static LLCachedControl<std::string> test_BrowserHomePage("BrowserHomePage", "hah
 void test_cached_control()
 {
 #define TEST_LLCC(T, V) if((T)mySetting_##T != V) LL_ERRS() << "Fail "#T << LL_ENDL
-	TEST_LLCC(U32, 666);
-	TEST_LLCC(S32, (S32)-666);
-	TEST_LLCC(F32, (F32)-666.666);
-	TEST_LLCC(bool, true);
-	TEST_LLCC(BOOL, FALSE);
-	if((std::string)mySetting_string != "Default String Value") LL_ERRS() << "Fail string" << LL_ENDL;
-	TEST_LLCC(LLVector3, LLVector3(1.0f, 2.0f, 3.0f));
-	TEST_LLCC(LLVector3d, LLVector3d(6.0f, 5.0f, 4.0f));
-	TEST_LLCC(LLRect, LLRect(0, 0, 100, 500));
-	TEST_LLCC(LLColor4, LLColor4(0.0f, 0.5f, 1.0f));
-	TEST_LLCC(LLColor3, LLColor3(1.0f, 0.f, 0.5f));
-	TEST_LLCC(LLColor4U, LLColor4U(255, 200, 100, 255));
-//There's no LLSD comparsion for LLCC yet. TEST_LLCC(LLSD, test_llsd); 
-
-	if((std::string)test_BrowserHomePage != "http://www.secondlife.com") LL_ERRS() << "Fail BrowserHomePage" << LL_ENDL;
+    TEST_LLCC(U32, 666);
+    TEST_LLCC(S32, (S32)-666);
+    TEST_LLCC(F32, (F32)-666.666);
+    TEST_LLCC(bool, true);
+    TEST_LLCC(BOOL, FALSE);
+    if((std::string)mySetting_string != "Default String Value") LL_ERRS() << "Fail string" << LL_ENDL;
+    TEST_LLCC(LLVector3, LLVector3(1.0f, 2.0f, 3.0f));
+    TEST_LLCC(LLVector3d, LLVector3d(6.0f, 5.0f, 4.0f));
+    TEST_LLCC(LLRect, LLRect(0, 0, 100, 500));
+    TEST_LLCC(LLColor4, LLColor4(0.0f, 0.5f, 1.0f));
+    TEST_LLCC(LLColor3, LLColor3(1.0f, 0.f, 0.5f));
+    TEST_LLCC(LLColor4U, LLColor4U(255, 200, 100, 255));
+//There's no LLSD comparsion for LLCC yet. TEST_LLCC(LLSD, test_llsd);
+
+    if((std::string)test_BrowserHomePage != "http://www.secondlife.com") LL_ERRS() << "Fail BrowserHomePage" << LL_ENDL;
 }
 #endif // TEST_CACHED_CONTROL
 
diff --git a/indra/llxml/llcontrol.h b/indra/llxml/llcontrol.h
index 5a8d688892..62b0c12770 100644
--- a/indra/llxml/llcontrol.h
+++ b/indra/llxml/llcontrol.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llcontrol.h
  * @brief A mechanism for storing "control state" for a program
  *
  * $LicenseInfo:firstyear=2001&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$
  */
@@ -48,13 +48,13 @@
 #include <boost/bind.hpp>
 
 #if LL_WINDOWS
-	#pragma warning (push)
-	#pragma warning (disable : 4263) // boost::signals2::expired_slot::what() has const mismatch
-	#pragma warning (disable : 4264) 
+    #pragma warning (push)
+    #pragma warning (disable : 4263) // boost::signals2::expired_slot::what() has const mismatch
+    #pragma warning (disable : 4264)
 #endif
 #include <boost/signals2.hpp>
 #if LL_WINDOWS
-	#pragma warning (pop)
+    #pragma warning (pop)
 #endif
 
 #if LL_WINDOWS
@@ -72,241 +72,241 @@ class LLColor3;
 // if this is changed, also modify mTypeString in llcontrol.h
 typedef enum e_control_type
 {
-	TYPE_U32 = 0,
-	TYPE_S32,
-	TYPE_F32,
-	TYPE_BOOLEAN,
-	TYPE_STRING,
-	TYPE_VEC3,
-	TYPE_VEC3D,
-	TYPE_QUAT,
-	TYPE_RECT,
-	TYPE_COL4,
-	TYPE_COL3,
-	TYPE_LLSD,
-	TYPE_COUNT
+    TYPE_U32 = 0,
+    TYPE_S32,
+    TYPE_F32,
+    TYPE_BOOLEAN,
+    TYPE_STRING,
+    TYPE_VEC3,
+    TYPE_VEC3D,
+    TYPE_QUAT,
+    TYPE_RECT,
+    TYPE_COL4,
+    TYPE_COL3,
+    TYPE_LLSD,
+    TYPE_COUNT
 } eControlType;
 
 class LLControlVariable : public LLRefCount
 {
-	LOG_CLASS(LLControlVariable);
+    LOG_CLASS(LLControlVariable);
+
+    friend class LLControlGroup;
 
-	friend class LLControlGroup;
-	
 public:
-	typedef boost::signals2::signal<bool(LLControlVariable* control, const LLSD&), boost_boolean_combiner> validate_signal_t;
-	typedef boost::signals2::signal<void(LLControlVariable* control, const LLSD&, const LLSD&)> commit_signal_t;
+    typedef boost::signals2::signal<bool(LLControlVariable* control, const LLSD&), boost_boolean_combiner> validate_signal_t;
+    typedef boost::signals2::signal<void(LLControlVariable* control, const LLSD&, const LLSD&)> commit_signal_t;
 
-	enum ePersist
-	{
-		PERSIST_NO,                 // don't save this var
-		PERSIST_NONDFT,             // save this var if differs from default
-		PERSIST_ALWAYS              // save this var even if has default value
-	};
+    enum ePersist
+    {
+        PERSIST_NO,                 // don't save this var
+        PERSIST_NONDFT,             // save this var if differs from default
+        PERSIST_ALWAYS              // save this var even if has default value
+    };
 
 private:
-	std::string		mName;
-	std::string		mComment;
-	eControlType	mType;
-	ePersist		mPersist;
-	bool			mHideFromSettingsEditor;
-	std::vector<LLSD> mValues;
-
-	commit_signal_t mCommitSignal;
-	validate_signal_t mValidateSignal;
-	
+    std::string     mName;
+    std::string     mComment;
+    eControlType    mType;
+    ePersist        mPersist;
+    bool            mHideFromSettingsEditor;
+    std::vector<LLSD> mValues;
+
+    commit_signal_t mCommitSignal;
+    validate_signal_t mValidateSignal;
+
 public:
-	LLControlVariable(const std::string& name, eControlType type,
-					  LLSD initial, const std::string& comment,
-					  ePersist persist = PERSIST_NONDFT, bool hidefromsettingseditor = false);
-
-	virtual ~LLControlVariable();
-	
-	const std::string& getName() const { return mName; }
-	const std::string& getComment() const { return mComment; }
-
-	eControlType type()		{ return mType; }
-	bool isType(eControlType tp) { return tp == mType; }
-
-	void resetToDefault(bool fire_signal = false);
-
-	commit_signal_t* getSignal() { return &mCommitSignal; } // shorthand for commit signal
-	commit_signal_t* getCommitSignal() { return &mCommitSignal; }
-	validate_signal_t* getValidateSignal() { return &mValidateSignal; }
-
-	bool isDefault() { return (mValues.size() == 1); }
-	bool shouldSave(bool nondefault_only);
-	bool isPersisted() { return mPersist != PERSIST_NO; }
-	bool isHiddenFromSettingsEditor() { return mHideFromSettingsEditor; }
-	LLSD get()			const	{ return getValue(); }
-	LLSD getValue()		const	{ return mValues.back(); }
-	LLSD getDefault()	const	{ return mValues.front(); }
-	LLSD getSaveValue() const;
-
-	void set(const LLSD& val, bool saved_value = true)	{ setValue(val, saved_value); }
-	void setValue(const LLSD& value, bool saved_value = TRUE);
-	void setDefaultValue(const LLSD& value);
-	void setPersist(ePersist);
-	void setHiddenFromSettingsEditor(bool hide);
-	void setComment(const std::string& comment);
+    LLControlVariable(const std::string& name, eControlType type,
+                      LLSD initial, const std::string& comment,
+                      ePersist persist = PERSIST_NONDFT, bool hidefromsettingseditor = false);
+
+    virtual ~LLControlVariable();
+
+    const std::string& getName() const { return mName; }
+    const std::string& getComment() const { return mComment; }
+
+    eControlType type()     { return mType; }
+    bool isType(eControlType tp) { return tp == mType; }
+
+    void resetToDefault(bool fire_signal = false);
+
+    commit_signal_t* getSignal() { return &mCommitSignal; } // shorthand for commit signal
+    commit_signal_t* getCommitSignal() { return &mCommitSignal; }
+    validate_signal_t* getValidateSignal() { return &mValidateSignal; }
+
+    bool isDefault() { return (mValues.size() == 1); }
+    bool shouldSave(bool nondefault_only);
+    bool isPersisted() { return mPersist != PERSIST_NO; }
+    bool isHiddenFromSettingsEditor() { return mHideFromSettingsEditor; }
+    LLSD get()          const   { return getValue(); }
+    LLSD getValue()     const   { return mValues.back(); }
+    LLSD getDefault()   const   { return mValues.front(); }
+    LLSD getSaveValue() const;
+
+    void set(const LLSD& val, bool saved_value = true)  { setValue(val, saved_value); }
+    void setValue(const LLSD& value, bool saved_value = TRUE);
+    void setDefaultValue(const LLSD& value);
+    void setPersist(ePersist);
+    void setHiddenFromSettingsEditor(bool hide);
+    void setComment(const std::string& comment);
 
 private:
-	void firePropertyChanged(const LLSD &pPreviousValue)
-	{
-		mCommitSignal(this, mValues.back(), pPreviousValue);
-	}
-	LLSD getComparableValue(const LLSD& value);
-	bool llsd_compare(const LLSD& a, const LLSD & b);
+    void firePropertyChanged(const LLSD &pPreviousValue)
+    {
+        mCommitSignal(this, mValues.back(), pPreviousValue);
+    }
+    LLSD getComparableValue(const LLSD& value);
+    bool llsd_compare(const LLSD& a, const LLSD & b);
 };
 
 typedef LLPointer<LLControlVariable> LLControlVariablePtr;
 
 //! Helper functions for converting between static types and LLControl values
-template <class T> 
+template <class T>
 eControlType get_control_type()
 {
-	LL_WARNS() << "Usupported control type: " << typeid(T).name() << "." << LL_ENDL;
-	return TYPE_COUNT;
+    LL_WARNS() << "Usupported control type: " << typeid(T).name() << "." << LL_ENDL;
+    return TYPE_COUNT;
 }
 
-template <class T> 
+template <class T>
 LLSD convert_to_llsd(const T& in)
 {
-	// default implementation
-	return LLSD(in);
+    // default implementation
+    return LLSD(in);
 }
 
 template <class T>
 T convert_from_llsd(const LLSD& sd, eControlType type, const std::string& control_name)
 {
-	// needs specialization
-	return T(sd);
+    // needs specialization
+    return T(sd);
 }
 
 //const U32 STRING_CACHE_SIZE = 10000;
 class LLControlGroup : public LLInstanceTracker<LLControlGroup, std::string>
 {
-	LOG_CLASS(LLControlGroup);
+    LOG_CLASS(LLControlGroup);
 
 protected:
-	typedef std::map<std::string, LLControlVariablePtr > ctrl_name_table_t;
-	ctrl_name_table_t mNameTable;
-	static const std::string mTypeString[TYPE_COUNT];
+    typedef std::map<std::string, LLControlVariablePtr > ctrl_name_table_t;
+    ctrl_name_table_t mNameTable;
+    static const std::string mTypeString[TYPE_COUNT];
 
 public:
-	static eControlType typeStringToEnum(const std::string& typestr);
-	static std::string typeEnumToString(eControlType typeenum);	
-
-	LLControlGroup(const std::string& name);
-	~LLControlGroup();
-	void cleanup();
-
-	LLControlVariablePtr getControl(const std::string& name);
-
-	struct ApplyFunctor
-	{
-		virtual ~ApplyFunctor() {};
-		virtual void apply(const std::string& name, LLControlVariable* control) = 0;
-	};
-	void applyToAll(ApplyFunctor* func);
-
-	LLControlVariable* declareControl(const std::string& name, eControlType type, const LLSD initial_val, const std::string& comment, LLControlVariable::ePersist persist, BOOL hidefromsettingseditor = FALSE);
-	LLControlVariable* declareU32(const std::string& name, U32 initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareS32(const std::string& name, S32 initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareF32(const std::string& name, F32 initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareBOOL(const std::string& name, BOOL initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareString(const std::string& name, const std::string &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareVec3(const std::string& name, const LLVector3 &initial_val,const std::string& comment,  LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareVec3d(const std::string& name, const LLVector3d &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareQuat(const std::string& name, const LLQuaternion &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareRect(const std::string& name, const LLRect &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareColor4(const std::string& name, const LLColor4 &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareColor3(const std::string& name, const LLColor3 &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-	LLControlVariable* declareLLSD(const std::string& name, const LLSD &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
-
-	std::string getString(const std::string& name);
-	std::string getText(const std::string& name);
-	BOOL		getBOOL(const std::string& name);
-	S32			getS32(const std::string& name);
-	F32			getF32(const std::string& name);
-	U32			getU32(const std::string& name);
-	
-	LLWString	getWString(const std::string& name);
-	LLVector3	getVector3(const std::string& name);
-	LLVector3d	getVector3d(const std::string& name);	
-	LLRect		getRect(const std::string& name);
-	LLSD        getLLSD(const std::string& name);
-	LLQuaternion	getQuaternion(const std::string& name);
-
-	LLColor4	getColor(const std::string& name);
-	LLColor4	getColor4(const std::string& name);
-	LLColor3	getColor3(const std::string& name);
-
-	LLSD		asLLSD(bool diffs_only);
-	
-	// generic getter
-	template<typename T> T get(const std::string& name)
-	{
+    static eControlType typeStringToEnum(const std::string& typestr);
+    static std::string typeEnumToString(eControlType typeenum);
+
+    LLControlGroup(const std::string& name);
+    ~LLControlGroup();
+    void cleanup();
+
+    LLControlVariablePtr getControl(const std::string& name);
+
+    struct ApplyFunctor
+    {
+        virtual ~ApplyFunctor() {};
+        virtual void apply(const std::string& name, LLControlVariable* control) = 0;
+    };
+    void applyToAll(ApplyFunctor* func);
+
+    LLControlVariable* declareControl(const std::string& name, eControlType type, const LLSD initial_val, const std::string& comment, LLControlVariable::ePersist persist, BOOL hidefromsettingseditor = FALSE);
+    LLControlVariable* declareU32(const std::string& name, U32 initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareS32(const std::string& name, S32 initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareF32(const std::string& name, F32 initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareBOOL(const std::string& name, BOOL initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareString(const std::string& name, const std::string &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareVec3(const std::string& name, const LLVector3 &initial_val,const std::string& comment,  LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareVec3d(const std::string& name, const LLVector3d &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareQuat(const std::string& name, const LLQuaternion &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareRect(const std::string& name, const LLRect &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareColor4(const std::string& name, const LLColor4 &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareColor3(const std::string& name, const LLColor3 &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+    LLControlVariable* declareLLSD(const std::string& name, const LLSD &initial_val, const std::string& comment, LLControlVariable::ePersist persist = LLControlVariable::PERSIST_NONDFT);
+
+    std::string getString(const std::string& name);
+    std::string getText(const std::string& name);
+    BOOL        getBOOL(const std::string& name);
+    S32         getS32(const std::string& name);
+    F32         getF32(const std::string& name);
+    U32         getU32(const std::string& name);
+
+    LLWString   getWString(const std::string& name);
+    LLVector3   getVector3(const std::string& name);
+    LLVector3d  getVector3d(const std::string& name);
+    LLRect      getRect(const std::string& name);
+    LLSD        getLLSD(const std::string& name);
+    LLQuaternion    getQuaternion(const std::string& name);
+
+    LLColor4    getColor(const std::string& name);
+    LLColor4    getColor4(const std::string& name);
+    LLColor3    getColor3(const std::string& name);
+
+    LLSD        asLLSD(bool diffs_only);
+
+    // generic getter
+    template<typename T> T get(const std::string& name)
+    {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_LLSD;
-		LLControlVariable* control = getControl(name);
-		LLSD value;
-		eControlType type = TYPE_COUNT;
-
-		if (control)		
-		{
-			value = control->get();
-			type = control->type();
-		}
-		else
-		{
-			LL_WARNS() << "Control " << name << " not found." << LL_ENDL;
-			return T();
-		}
-		return convert_from_llsd<T>(value, type, name);
-	}
-
-	void	setBOOL(const std::string& name, BOOL val);
-	void	setS32(const std::string& name, S32 val);
-	void	setF32(const std::string& name, F32 val);
-	void	setU32(const std::string& name, U32 val);
-	void	setString(const std::string&  name, const std::string& val);
-	void	setVector3(const std::string& name, const LLVector3 &val);
-	void	setVector3d(const std::string& name, const LLVector3d &val);
-	void	setQuaternion(const std::string& name, const LLQuaternion &val);
-	void	setRect(const std::string& name, const LLRect &val);
-	void	setColor4(const std::string& name, const LLColor4 &val);
-	void    setLLSD(const std::string& name, const LLSD& val);
-
-	// type agnostic setter that takes LLSD
-	void	setUntypedValue(const std::string& name, const LLSD& val, bool saved_value = true);
-
-	// generic setter
-	template<typename T> void set(const std::string& name, const T& val)
-	{
-		LLControlVariable* control = getControl(name);
-	
-		if (control && control->isType(get_control_type<T>()))
-		{
-			control->set(convert_to_llsd(val));
-		}
-		else
-		{
-			LL_WARNS() << "Invalid control " << name << LL_ENDL;
-		}
-	}
-	
-	BOOL    controlExists(const std::string& name);
-
-	// Returns number of controls loaded, 0 if failed
-	// If require_declaration is false, will auto-declare controls it finds
-	// as the given type.
-	U32	loadFromFileLegacy(const std::string& filename, BOOL require_declaration = TRUE, eControlType declare_as = TYPE_STRING);
- 	U32 saveToFile(const std::string& filename, BOOL nondefault_only);
- 	U32	loadFromFile(const std::string& filename, bool default_values = false, bool save_values = true);
-	void	resetToDefaults();
-	void	incrCount(const std::string& name);
-
-	bool	mSettingsProfile;
+        LLControlVariable* control = getControl(name);
+        LLSD value;
+        eControlType type = TYPE_COUNT;
+
+        if (control)
+        {
+            value = control->get();
+            type = control->type();
+        }
+        else
+        {
+            LL_WARNS() << "Control " << name << " not found." << LL_ENDL;
+            return T();
+        }
+        return convert_from_llsd<T>(value, type, name);
+    }
+
+    void    setBOOL(const std::string& name, BOOL val);
+    void    setS32(const std::string& name, S32 val);
+    void    setF32(const std::string& name, F32 val);
+    void    setU32(const std::string& name, U32 val);
+    void    setString(const std::string&  name, const std::string& val);
+    void    setVector3(const std::string& name, const LLVector3 &val);
+    void    setVector3d(const std::string& name, const LLVector3d &val);
+    void    setQuaternion(const std::string& name, const LLQuaternion &val);
+    void    setRect(const std::string& name, const LLRect &val);
+    void    setColor4(const std::string& name, const LLColor4 &val);
+    void    setLLSD(const std::string& name, const LLSD& val);
+
+    // type agnostic setter that takes LLSD
+    void    setUntypedValue(const std::string& name, const LLSD& val, bool saved_value = true);
+
+    // generic setter
+    template<typename T> void set(const std::string& name, const T& val)
+    {
+        LLControlVariable* control = getControl(name);
+
+        if (control && control->isType(get_control_type<T>()))
+        {
+            control->set(convert_to_llsd(val));
+        }
+        else
+        {
+            LL_WARNS() << "Invalid control " << name << LL_ENDL;
+        }
+    }
+
+    BOOL    controlExists(const std::string& name);
+
+    // Returns number of controls loaded, 0 if failed
+    // If require_declaration is false, will auto-declare controls it finds
+    // as the given type.
+    U32 loadFromFileLegacy(const std::string& filename, BOOL require_declaration = TRUE, eControlType declare_as = TYPE_STRING);
+    U32 saveToFile(const std::string& filename, BOOL nondefault_only);
+    U32 loadFromFile(const std::string& filename, bool default_values = false, bool save_values = true);
+    void    resetToDefaults();
+    void    incrCount(const std::string& name);
+
+    bool    mSettingsProfile;
 };
 
 
@@ -319,124 +319,124 @@ template <class T>
 class LLControlCache : public LLRefCount, public LLInstanceTracker<LLControlCache<T>, std::string>
 {
 public:
-	// This constructor will declare a control if it doesn't exist in the contol group
-	LLControlCache(LLControlGroup& group,
-					const std::string& name, 
-					const T& default_value, 
-					const std::string& comment)
-	:	LLInstanceTracker<LLControlCache<T>, std::string >(name)
-	{
-		if(!group.controlExists(name))
-		{
-			if(!declareTypedControl(group, name, default_value, comment))
-			{
-				LL_ERRS() << "The control could not be created!!!" << LL_ENDL;
-			}
-		}
-
-		bindToControl(group, name);
-	}
-
-	LLControlCache(LLControlGroup& group,
-					const std::string& name)
-	:	LLInstanceTracker<LLControlCache<T>, std::string >(name)
-	{
-		if(!group.controlExists(name))
-		{
-			LL_ERRS() << "Control named " << name << "not found." << LL_ENDL;
-		}
-
-		bindToControl(group, name);
-	}
-
-	~LLControlCache()
-	{
-	}
-
-	const T& getValue() const { return mCachedValue; }
-	
+    // This constructor will declare a control if it doesn't exist in the contol group
+    LLControlCache(LLControlGroup& group,
+                    const std::string& name,
+                    const T& default_value,
+                    const std::string& comment)
+    :   LLInstanceTracker<LLControlCache<T>, std::string >(name)
+    {
+        if(!group.controlExists(name))
+        {
+            if(!declareTypedControl(group, name, default_value, comment))
+            {
+                LL_ERRS() << "The control could not be created!!!" << LL_ENDL;
+            }
+        }
+
+        bindToControl(group, name);
+    }
+
+    LLControlCache(LLControlGroup& group,
+                    const std::string& name)
+    :   LLInstanceTracker<LLControlCache<T>, std::string >(name)
+    {
+        if(!group.controlExists(name))
+        {
+            LL_ERRS() << "Control named " << name << "not found." << LL_ENDL;
+        }
+
+        bindToControl(group, name);
+    }
+
+    ~LLControlCache()
+    {
+    }
+
+    const T& getValue() const { return mCachedValue; }
+
 private:
-	void bindToControl(LLControlGroup& group, const std::string& name)
-	{
-		LLControlVariablePtr controlp = group.getControl(name);
-		mType = controlp->type();
-		mCachedValue = convert_from_llsd<T>(controlp->get(), mType, name);
-
-		// Add a listener to the controls signal...
-		// NOTE: All listeners connected to 0 group, for guaranty that variable handlers (gSavedSettings) call last
-		mConnection = controlp->getSignal()->connect(0,
-			boost::bind(&LLControlCache<T>::handleValueChange, this, _2)
-			);
-		mType = controlp->type();
-	}
-	bool declareTypedControl(LLControlGroup& group,
-							const std::string& name, 
-							 const T& default_value,
-							 const std::string& comment)
-	{
-		LLSD init_value;
-		eControlType type = get_control_type<T>();
-		init_value = convert_to_llsd(default_value);
-		if(type < TYPE_COUNT)
-		{
-			group.declareControl(name, type, init_value, comment, LLControlVariable::PERSIST_NO);
-			return true;
-		}
-		return false;
-	}
-
-	bool handleValueChange(const LLSD& newvalue)
-	{
-		mCachedValue = convert_from_llsd<T>(newvalue, mType, "");
-		return true;
-	}
+    void bindToControl(LLControlGroup& group, const std::string& name)
+    {
+        LLControlVariablePtr controlp = group.getControl(name);
+        mType = controlp->type();
+        mCachedValue = convert_from_llsd<T>(controlp->get(), mType, name);
+
+        // Add a listener to the controls signal...
+        // NOTE: All listeners connected to 0 group, for guaranty that variable handlers (gSavedSettings) call last
+        mConnection = controlp->getSignal()->connect(0,
+            boost::bind(&LLControlCache<T>::handleValueChange, this, _2)
+            );
+        mType = controlp->type();
+    }
+    bool declareTypedControl(LLControlGroup& group,
+                            const std::string& name,
+                             const T& default_value,
+                             const std::string& comment)
+    {
+        LLSD init_value;
+        eControlType type = get_control_type<T>();
+        init_value = convert_to_llsd(default_value);
+        if(type < TYPE_COUNT)
+        {
+            group.declareControl(name, type, init_value, comment, LLControlVariable::PERSIST_NO);
+            return true;
+        }
+        return false;
+    }
+
+    bool handleValueChange(const LLSD& newvalue)
+    {
+        mCachedValue = convert_from_llsd<T>(newvalue, mType, "");
+        return true;
+    }
 
 private:
-    T							mCachedValue;
-	eControlType				mType;
-    boost::signals2::scoped_connection	mConnection;
+    T                           mCachedValue;
+    eControlType                mType;
+    boost::signals2::scoped_connection  mConnection;
 };
 
 template <typename T>
 class LLCachedControl
 {
 public:
-	LLCachedControl(LLControlGroup& group,
-					const std::string& name,
-					const T& default_value, 
-					const std::string& comment = "Declared In Code")
-	{
-		mCachedControlPtr = LLControlCache<T>::getInstance(name).get();
-		if (! mCachedControlPtr)
-		{
-			mCachedControlPtr = new LLControlCache<T>(group, name, default_value, comment);
-		}
-	}
-
-	LLCachedControl(LLControlGroup& group,
-					const std::string& name)
-	{
-		mCachedControlPtr = LLControlCache<T>::getInstance(name).get();
-		if (! mCachedControlPtr)
-		{
-			mCachedControlPtr = new LLControlCache<T>(group, name);
-		}
-	}
-
-	operator const T&() const { return mCachedControlPtr->getValue(); }
-	operator boost::function<const T&()> () const { return boost::function<const T&()>(*this); }
-	const T& operator()() { return mCachedControlPtr->getValue(); }
+    LLCachedControl(LLControlGroup& group,
+                    const std::string& name,
+                    const T& default_value,
+                    const std::string& comment = "Declared In Code")
+    {
+        mCachedControlPtr = LLControlCache<T>::getInstance(name).get();
+        if (! mCachedControlPtr)
+        {
+            mCachedControlPtr = new LLControlCache<T>(group, name, default_value, comment);
+        }
+    }
+
+    LLCachedControl(LLControlGroup& group,
+                    const std::string& name)
+    {
+        mCachedControlPtr = LLControlCache<T>::getInstance(name).get();
+        if (! mCachedControlPtr)
+        {
+            mCachedControlPtr = new LLControlCache<T>(group, name);
+        }
+    }
+
+    operator const T&() const { return mCachedControlPtr->getValue(); }
+    operator boost::function<const T&()> () const { return boost::function<const T&()>(*this); }
+    const T& operator()() { return mCachedControlPtr->getValue(); }
 
 private:
-	LLPointer<LLControlCache<T> > mCachedControlPtr;
+    LLPointer<LLControlCache<T> > mCachedControlPtr;
 };
 
 template <> eControlType get_control_type<U32>();
 template <> eControlType get_control_type<S32>();
 template <> eControlType get_control_type<F32>();
-template <> eControlType get_control_type<bool>(); 
+template <> eControlType get_control_type<bool>();
 // Yay BOOL, its really an S32.
-//template <> eControlType get_control_type<BOOL> () 
+//template <> eControlType get_control_type<BOOL> ()
 template <> eControlType get_control_type<std::string>();
 template <> eControlType get_control_type<LLVector3>();
 template <> eControlType get_control_type<LLVector3d>();