From c3da5bb12d1c7c173929433589a4068555791bea Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 15 May 2024 09:11:29 -0400
Subject: Manual whitespace fixes (fix_whitespace.py).
---
indra/llxml/llcontrol.cpp | 1830 ++++++++++++++++++++++-----------------------
indra/llxml/llcontrol.h | 614 +++++++--------
2 files changed, 1222 insertions(+), 1222 deletions(-)
(limited to 'indra/llxml')
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>();
--
cgit v1.2.3