612 lines
17 KiB
C++
612 lines
17 KiB
C++
/**
|
|
* @file llfloatersettingsdebug.cpp
|
|
* @brief floater for debugging internal viewer settings
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2001-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "llfloatersettingsdebug.h"
|
|
|
|
#include "llcolorswatch.h"
|
|
#include "llfloater.h"
|
|
#include "llscrolllistctrl.h"
|
|
#include "llscrolllistitem.h"
|
|
#include "llsdserialize.h"
|
|
#include "llspinctrl.h"
|
|
#include "lltexteditor.h"
|
|
#include "lluictrlfactory.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llwindow.h"
|
|
|
|
LLFloaterSettingsDebug::LLFloaterSettingsDebug()
|
|
: LLFloater(std::string("Configuration Editor"))
|
|
, mOldSearchTerm("---")
|
|
, mCurrentControlVariable(nullptr)
|
|
, mSettingsScrollList(nullptr)
|
|
, mValSpinner1(nullptr)
|
|
, mValSpinner2(nullptr)
|
|
, mValSpinner3(nullptr)
|
|
, mValSpinner4(nullptr)
|
|
, mValColor(nullptr)
|
|
, mValBool(nullptr)
|
|
, mValText(nullptr)
|
|
, mComment(nullptr)
|
|
, mBtnCopy(nullptr)
|
|
, mBtnDefault(nullptr)
|
|
{
|
|
mCommitCallbackRegistrar.add("SettingSelect", boost::bind(&LLFloaterSettingsDebug::onSettingSelect, this));
|
|
mCommitCallbackRegistrar.add("CommitSettings", boost::bind(&LLFloaterSettingsDebug::onCommitSettings, this));
|
|
mCommitCallbackRegistrar.add("ClickDefault", boost::bind(&LLFloaterSettingsDebug::onClickDefault, this));
|
|
mCommitCallbackRegistrar.add("UpdateFilter", boost::bind(&LLFloaterSettingsDebug::onUpdateFilter, this, _2));
|
|
mCommitCallbackRegistrar.add("ClickCopy", boost::bind(&LLFloaterSettingsDebug::onCopyToClipboard, this));
|
|
|
|
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_settings_debug.xml");
|
|
}
|
|
|
|
LLFloaterSettingsDebug::~LLFloaterSettingsDebug()
|
|
{
|
|
if (mCurrentControlVariable)
|
|
mCurrentControlVariable->getCommitSignal()->disconnect(boost::bind(&LLFloaterSettingsDebug::updateControl, this));
|
|
}
|
|
|
|
BOOL LLFloaterSettingsDebug::postBuild()
|
|
{
|
|
mSettingsScrollList = getChild<LLScrollListCtrl>("settings_scroll_list");
|
|
|
|
struct f final : public LLControlGroup::ApplyFunctor
|
|
{
|
|
settings_map_t* map;
|
|
f(settings_map_t* m) : map(m) {}
|
|
|
|
void apply(const std::string& name, LLControlVariable* control) override final
|
|
{
|
|
if (!control->isHiddenFromSettingsEditor())
|
|
{
|
|
(*map)[name]=control;
|
|
}
|
|
}
|
|
} func(&mSettingsMap);
|
|
|
|
gSavedSettings.applyToAll(&func);
|
|
gSavedPerAccountSettings.applyToAll(&func);
|
|
gColors.applyToAll(&func);
|
|
|
|
// Populate the list
|
|
for(const auto& pair : mSettingsMap)
|
|
addRow(pair.second);
|
|
|
|
mSettingsScrollList->sortByColumnIndex(0, true);
|
|
mComment = getChild<LLTextEditor>("comment_text");
|
|
mValSpinner1 = getChild<LLSpinCtrl>("val_spinner_1");
|
|
mValSpinner2 = getChild<LLSpinCtrl>("val_spinner_2");
|
|
mValSpinner3 = getChild<LLSpinCtrl>("val_spinner_3");
|
|
mValSpinner4 = getChild<LLSpinCtrl>("val_spinner_4");
|
|
mValColor = getChild<LLColorSwatchCtrl>("val_color_swatch");
|
|
mValBool = getChild<LLUICtrl>("boolean_combo");
|
|
mValText = getChild<LLUICtrl>("val_text");
|
|
mBtnCopy = getChildView("copy_btn");
|
|
mBtnDefault = getChildView("default_btn");
|
|
|
|
LL_INFOS() << mSettingsScrollList->getItemCount() << " total debug settings displayed." << LL_ENDL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::draw()
|
|
{
|
|
// check for changes in control visibility, like RLVa does
|
|
if (mCurrentControlVariable && mCurrentControlVariable->isHiddenFromSettingsEditor() != mOldVisibility)
|
|
updateControl();
|
|
|
|
LLFloater::draw();
|
|
}
|
|
|
|
LLControlVariable* LLFloaterSettingsDebug::getControlVariable()
|
|
{
|
|
LLScrollListItem* item = mSettingsScrollList->getFirstSelected();
|
|
if (!item) return nullptr;
|
|
|
|
LLControlVariable* controlp = static_cast<LLControlVariable*>(item->getUserdata());
|
|
|
|
return controlp ? controlp->getCOAActive() : nullptr;
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::addRow(LLControlVariable* control, const std::string& searchTerm)
|
|
{
|
|
const auto& name = control->getName();
|
|
const auto& comment = control->getComment();
|
|
|
|
if (!searchTerm.empty())
|
|
{
|
|
std::string itemValue = control->getName();
|
|
LLStringUtil::toLower(itemValue);
|
|
if (itemValue.find(searchTerm, 0) == std::string::npos)
|
|
{
|
|
std::string itemComment = control->getComment();
|
|
LLStringUtil::toLower(itemComment);
|
|
if (itemComment.find(searchTerm, 0) == std::string::npos)
|
|
return;
|
|
}
|
|
}
|
|
|
|
auto params = LLScrollListItem::Params();
|
|
params.userdata(control)
|
|
.columns.add(LLScrollListCell::Params()
|
|
.value(name)
|
|
.tool_tip(comment));
|
|
mSettingsScrollList->addRow(params);
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::onSettingSelect()
|
|
{
|
|
auto new_control = getControlVariable();
|
|
|
|
if (new_control == mCurrentControlVariable) return;
|
|
|
|
// unbind change control signal from previously selected control
|
|
if (mCurrentControlVariable)
|
|
mCurrentControlVariable->getCommitSignal()->disconnect(boost::bind(&LLFloaterSettingsDebug::updateControl, this));
|
|
|
|
mCurrentControlVariable = new_control;
|
|
|
|
// bind change control signal, so we can see updates to the current control in realtime
|
|
if (mCurrentControlVariable)
|
|
mCurrentControlVariable->getCommitSignal()->connect(boost::bind(&LLFloaterSettingsDebug::updateControl, this));
|
|
|
|
updateControl();
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::onCommitSettings()
|
|
{
|
|
LLControlVariable* controlp = mCurrentControlVariable;
|
|
|
|
if (!controlp)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLVector3 vector;
|
|
LLVector3d vectord;
|
|
LLRect rect;
|
|
LLColor4 col4;
|
|
LLColor3 col3;
|
|
LLColor4U col4U;
|
|
LLColor4 color_with_alpha;
|
|
|
|
switch(controlp->type())
|
|
{
|
|
case TYPE_U32:
|
|
controlp->set(mValSpinner1->getValue());
|
|
break;
|
|
case TYPE_S32:
|
|
controlp->set(mValSpinner1->getValue());
|
|
break;
|
|
case TYPE_F32:
|
|
controlp->set(LLSD(mValSpinner1->getValue().asReal()));
|
|
break;
|
|
case TYPE_BOOLEAN:
|
|
controlp->set(mValBool->getValue());
|
|
break;
|
|
case TYPE_STRING:
|
|
controlp->set(mValText->getValue());
|
|
break;
|
|
case TYPE_VEC3:
|
|
vector.mV[VX] = (F32)mValSpinner1->getValue().asReal();
|
|
vector.mV[VY] = (F32)mValSpinner2->getValue().asReal();
|
|
vector.mV[VZ] = (F32)mValSpinner3->getValue().asReal();
|
|
controlp->set(vector.getValue());
|
|
break;
|
|
case TYPE_VEC3D:
|
|
vectord.mdV[VX] = mValSpinner1->getValue().asReal();
|
|
vectord.mdV[VY] = mValSpinner2->getValue().asReal();
|
|
vectord.mdV[VZ] = mValSpinner3->getValue().asReal();
|
|
controlp->set(vectord.getValue());
|
|
break;
|
|
case TYPE_RECT:
|
|
rect.mLeft = mValSpinner1->getValue().asInteger();
|
|
rect.mRight = mValSpinner2->getValue().asInteger();
|
|
rect.mBottom = mValSpinner3->getValue().asInteger();
|
|
rect.mTop = mValSpinner4->getValue().asInteger();
|
|
controlp->set(rect.getValue());
|
|
break;
|
|
case TYPE_COL4:
|
|
col3.setValue(mValColor->getValue());
|
|
col4 = LLColor4(col3, (F32)mValSpinner4->getValue().asReal());
|
|
controlp->set(col4.getValue());
|
|
break;
|
|
case TYPE_COL3:
|
|
controlp->set(mValColor->getValue());
|
|
//col3.mV[VRED] = (F32)mValSpinner1->getValue().asReal();
|
|
//col3.mV[VGREEN] = (F32)mValSpinner2->getValue().asReal();
|
|
//col3.mV[VBLUE] = (F32)mValSpinner3->getValue().asReal();
|
|
//mCurrentControlVariable->set(col3.getValue());
|
|
break;
|
|
case TYPE_COL4U:
|
|
col3.setValue(mValColor->getValue());
|
|
col4U.setVecScaleClamp(col3);
|
|
col4U.mV[VALPHA] = mValSpinner4->getValue().asInteger();
|
|
mCurrentControlVariable->set(col4U.getValue());
|
|
break;
|
|
case TYPE_LLSD:
|
|
{
|
|
const auto& val = mValText->getValue().asString();
|
|
LLSD sd;
|
|
if (!val.empty())
|
|
{
|
|
std::istringstream str(val);
|
|
if (LLSDSerialize::fromXML(sd, str) == LLSDParser::PARSE_FAILURE)
|
|
break;
|
|
}
|
|
mCurrentControlVariable->set(sd);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::onClickDefault()
|
|
{
|
|
if (mCurrentControlVariable)
|
|
{
|
|
mCurrentControlVariable->resetToDefault(true);
|
|
updateControl();
|
|
}
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::onCopyToClipboard()
|
|
{
|
|
if (mCurrentControlVariable)
|
|
{
|
|
getWindow()->copyTextToClipboard(utf8str_to_wstring(mCurrentControlVariable->getName()));
|
|
}
|
|
}
|
|
|
|
// we've switched controls, or doing per-frame update, so update spinners, etc.
|
|
void LLFloaterSettingsDebug::updateControl()
|
|
{
|
|
if (!mValSpinner1 || !mValSpinner2 || !mValSpinner3 || !mValSpinner4 || !mValColor)
|
|
{
|
|
LL_WARNS() << "Could not find all desired controls by name"
|
|
<< LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
mValSpinner1->setVisible(FALSE);
|
|
mValSpinner2->setVisible(FALSE);
|
|
mValSpinner3->setVisible(FALSE);
|
|
mValSpinner4->setVisible(FALSE);
|
|
mValColor->setVisible(FALSE);
|
|
mValText->setVisible(FALSE);
|
|
if (!mComment->hasFocus()) // <alchemy/>
|
|
{
|
|
mComment->setText(LLStringUtil::null);
|
|
}
|
|
mValBool->setVisible(false);
|
|
mBtnCopy->setEnabled(false);
|
|
mBtnDefault->setEnabled(false);
|
|
|
|
if (mCurrentControlVariable)
|
|
{
|
|
// [RLVa:KB] - Checked: 2011-05-28 (RLVa-1.4.0a) | Modified: RLVa-1.4.0a
|
|
// If "HideFromEditor" was toggled while the floater is open then we need to manually disable access to the control
|
|
mOldVisibility = mCurrentControlVariable->isHiddenFromSettingsEditor();
|
|
mValSpinner1->setEnabled(!mOldVisibility);
|
|
mValSpinner2->setEnabled(!mOldVisibility);
|
|
mValSpinner3->setEnabled(!mOldVisibility);
|
|
mValSpinner4->setEnabled(!mOldVisibility);
|
|
mValColor->setEnabled(!mOldVisibility);
|
|
mValText->setEnabled(!mOldVisibility);
|
|
mValBool->setEnabled(!mOldVisibility);
|
|
mBtnDefault->setEnabled(!mOldVisibility);
|
|
// [/RLVa:KB]
|
|
|
|
mBtnCopy->setEnabled(true);
|
|
|
|
eControlType type = mCurrentControlVariable->type();
|
|
if (!mComment->hasFocus()) // <alchemy/>
|
|
{
|
|
mComment->setText(mCurrentControlVariable->getName() + std::string(": ") + mCurrentControlVariable->getComment());
|
|
}
|
|
mValSpinner1->setMaxValue(F32_MAX);
|
|
mValSpinner2->setMaxValue(F32_MAX);
|
|
mValSpinner3->setMaxValue(F32_MAX);
|
|
mValSpinner4->setMaxValue(F32_MAX);
|
|
mValSpinner1->setMinValue(-F32_MAX);
|
|
mValSpinner2->setMinValue(-F32_MAX);
|
|
mValSpinner3->setMinValue(-F32_MAX);
|
|
mValSpinner4->setMinValue(-F32_MAX);
|
|
if (!mValSpinner1->hasFocus())
|
|
{
|
|
mValSpinner1->setIncrement(0.1f);
|
|
}
|
|
if (!mValSpinner2->hasFocus())
|
|
{
|
|
mValSpinner2->setIncrement(0.1f);
|
|
}
|
|
if (!mValSpinner3->hasFocus())
|
|
{
|
|
mValSpinner3->setIncrement(0.1f);
|
|
}
|
|
if (!mValSpinner4->hasFocus())
|
|
{
|
|
mValSpinner4->setIncrement(0.1f);
|
|
}
|
|
|
|
LLSD sd = mCurrentControlVariable->get();
|
|
switch(type)
|
|
{
|
|
case TYPE_U32:
|
|
mValSpinner1->setVisible(TRUE);
|
|
mValSpinner1->setLabel(LLStringExplicit("value")); // Debug, don't translate
|
|
if (!mValSpinner1->hasFocus())
|
|
{
|
|
mValSpinner1->setValue(sd);
|
|
mValSpinner1->setMinValue((F32)U32_MIN);
|
|
mValSpinner1->setMaxValue((F32)U32_MAX);
|
|
mValSpinner1->setIncrement(1.f);
|
|
mValSpinner1->setPrecision(0);
|
|
}
|
|
break;
|
|
case TYPE_S32:
|
|
mValSpinner1->setVisible(TRUE);
|
|
mValSpinner1->setLabel(LLStringExplicit("value")); // Debug, don't translate
|
|
if (!mValSpinner1->hasFocus())
|
|
{
|
|
mValSpinner1->setValue(sd);
|
|
mValSpinner1->setMinValue((F32)S32_MIN);
|
|
mValSpinner1->setMaxValue((F32)S32_MAX);
|
|
mValSpinner1->setIncrement(1.f);
|
|
mValSpinner1->setPrecision(0);
|
|
}
|
|
break;
|
|
case TYPE_F32:
|
|
mValSpinner1->setVisible(TRUE);
|
|
mValSpinner1->setLabel(LLStringExplicit("value")); // Debug, don't translate
|
|
if (!mValSpinner1->hasFocus())
|
|
{
|
|
mValSpinner1->setPrecision(3);
|
|
mValSpinner1->setValue(sd);
|
|
}
|
|
break;
|
|
case TYPE_BOOLEAN:
|
|
mValBool->setVisible(true);
|
|
if (!mValBool->hasFocus())
|
|
{
|
|
mValBool->setValue(LLSD(sd.asBoolean() ? "TRUE" : "FALSE"));
|
|
}
|
|
break;
|
|
case TYPE_STRING:
|
|
mValText->setVisible(TRUE);
|
|
if (!mValText->hasFocus())
|
|
{
|
|
mValText->setValue(sd);
|
|
}
|
|
break;
|
|
case TYPE_VEC3:
|
|
{
|
|
LLVector3 v;
|
|
v.setValue(sd);
|
|
mValSpinner1->setVisible(TRUE);
|
|
mValSpinner1->setLabel(LLStringExplicit("X"));
|
|
mValSpinner2->setVisible(TRUE);
|
|
mValSpinner2->setLabel(LLStringExplicit("Y"));
|
|
mValSpinner3->setVisible(TRUE);
|
|
mValSpinner3->setLabel(LLStringExplicit("Z"));
|
|
if (!mValSpinner1->hasFocus())
|
|
{
|
|
mValSpinner1->setPrecision(3);
|
|
mValSpinner1->setValue(v[VX]);
|
|
}
|
|
if (!mValSpinner2->hasFocus())
|
|
{
|
|
mValSpinner2->setPrecision(3);
|
|
mValSpinner2->setValue(v[VY]);
|
|
}
|
|
if (!mValSpinner3->hasFocus())
|
|
{
|
|
mValSpinner3->setPrecision(3);
|
|
mValSpinner3->setValue(v[VZ]);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_VEC3D:
|
|
{
|
|
LLVector3d v;
|
|
v.setValue(sd);
|
|
mValSpinner1->setVisible(TRUE);
|
|
mValSpinner1->setLabel(LLStringExplicit("X"));
|
|
mValSpinner2->setVisible(TRUE);
|
|
mValSpinner2->setLabel(LLStringExplicit("Y"));
|
|
mValSpinner3->setVisible(TRUE);
|
|
mValSpinner3->setLabel(LLStringExplicit("Z"));
|
|
if (!mValSpinner1->hasFocus())
|
|
{
|
|
mValSpinner1->setPrecision(3);
|
|
mValSpinner1->setValue(v[VX]);
|
|
}
|
|
if (!mValSpinner2->hasFocus())
|
|
{
|
|
mValSpinner2->setPrecision(3);
|
|
mValSpinner2->setValue(v[VY]);
|
|
}
|
|
if (!mValSpinner3->hasFocus())
|
|
{
|
|
mValSpinner3->setPrecision(3);
|
|
mValSpinner3->setValue(v[VZ]);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_RECT:
|
|
{
|
|
LLRect r;
|
|
r.setValue(sd);
|
|
mValSpinner1->setVisible(TRUE);
|
|
mValSpinner1->setLabel(LLStringExplicit("Left"));
|
|
mValSpinner2->setVisible(TRUE);
|
|
mValSpinner2->setLabel(LLStringExplicit("Right"));
|
|
mValSpinner3->setVisible(TRUE);
|
|
mValSpinner3->setLabel(LLStringExplicit("Bottom"));
|
|
mValSpinner4->setVisible(TRUE);
|
|
mValSpinner4->setLabel(LLStringExplicit("Top"));
|
|
if (!mValSpinner1->hasFocus())
|
|
{
|
|
mValSpinner1->setPrecision(0);
|
|
mValSpinner1->setValue(r.mLeft);
|
|
}
|
|
if (!mValSpinner2->hasFocus())
|
|
{
|
|
mValSpinner2->setPrecision(0);
|
|
mValSpinner2->setValue(r.mRight);
|
|
}
|
|
if (!mValSpinner3->hasFocus())
|
|
{
|
|
mValSpinner3->setPrecision(0);
|
|
mValSpinner3->setValue(r.mBottom);
|
|
}
|
|
if (!mValSpinner4->hasFocus())
|
|
{
|
|
mValSpinner4->setPrecision(0);
|
|
mValSpinner4->setValue(r.mTop);
|
|
}
|
|
|
|
mValSpinner1->setMinValue((F32)S32_MIN);
|
|
mValSpinner1->setMaxValue((F32)S32_MAX);
|
|
mValSpinner1->setIncrement(1.f);
|
|
|
|
mValSpinner2->setMinValue((F32)S32_MIN);
|
|
mValSpinner2->setMaxValue((F32)S32_MAX);
|
|
mValSpinner2->setIncrement(1.f);
|
|
|
|
mValSpinner3->setMinValue((F32)S32_MIN);
|
|
mValSpinner3->setMaxValue((F32)S32_MAX);
|
|
mValSpinner3->setIncrement(1.f);
|
|
|
|
mValSpinner4->setMinValue((F32)S32_MIN);
|
|
mValSpinner4->setMaxValue((F32)S32_MAX);
|
|
mValSpinner4->setIncrement(1.f);
|
|
break;
|
|
}
|
|
case TYPE_COL4:
|
|
{
|
|
LLColor4 clr;
|
|
clr.setValue(sd);
|
|
mValColor->setVisible(TRUE);
|
|
// only set if changed so color picker doesn't update
|
|
if(clr != LLColor4(mValColor->getValue()))
|
|
{
|
|
mValColor->set(LLColor4(sd), TRUE, FALSE);
|
|
}
|
|
mValSpinner4->setVisible(TRUE);
|
|
mValSpinner4->setLabel(LLStringExplicit("Alpha"));
|
|
if (!mValSpinner4->hasFocus())
|
|
{
|
|
mValSpinner4->setPrecision(3);
|
|
mValSpinner4->setMinValue(0.0);
|
|
mValSpinner4->setMaxValue(1.f);
|
|
mValSpinner4->setValue(clr.mV[VALPHA]);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_COL3:
|
|
{
|
|
LLColor3 clr;
|
|
clr.setValue(sd);
|
|
mValColor->setVisible(TRUE);
|
|
mValColor->setValue(sd);
|
|
break;
|
|
}
|
|
case TYPE_COL4U:
|
|
{
|
|
LLColor4U clr(sd);
|
|
mValColor->setVisible(TRUE);
|
|
if (LLColor4(clr) != LLColor4(mValColor->getValue()))
|
|
{
|
|
mValColor->set(LLColor4(clr), TRUE, FALSE);
|
|
}
|
|
mValSpinner4->setVisible(TRUE);
|
|
mValSpinner4->setLabel(std::string("Alpha"));
|
|
if(!mValSpinner4->hasFocus())
|
|
{
|
|
mValSpinner4->setPrecision(0);
|
|
mValSpinner4->setValue(clr.mV[VALPHA]);
|
|
}
|
|
|
|
mValSpinner4->setMinValue(0);
|
|
mValSpinner4->setMaxValue(255);
|
|
mValSpinner4->setIncrement(1.f);
|
|
|
|
break;
|
|
}
|
|
case TYPE_LLSD:
|
|
mValText->setVisible(true);
|
|
{
|
|
std::ostringstream str;
|
|
LLSDSerialize::toPrettyXML(sd, str);
|
|
mValText->setValue(str.str());
|
|
}
|
|
break;
|
|
default:
|
|
mComment->setText(LLStringExplicit("unknown"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::onUpdateFilter(const LLSD& value)
|
|
{
|
|
updateFilter(value.asString());
|
|
}
|
|
|
|
void LLFloaterSettingsDebug::updateFilter(std::string searchTerm)
|
|
{
|
|
LLStringUtil::toLower(searchTerm);
|
|
|
|
// make sure not to reselect the first item in the list on focus restore
|
|
if (searchTerm == mOldSearchTerm) return;
|
|
|
|
mOldSearchTerm = searchTerm;
|
|
|
|
mSettingsScrollList->deleteAllItems();
|
|
|
|
for(const auto& pair : mSettingsMap)
|
|
addRow(pair.second, searchTerm);
|
|
|
|
mSettingsScrollList->sortByColumnIndex(0, true);
|
|
|
|
// if at least one match was found, highlight and select the topmost entry in the list
|
|
// but only if actually a search term was given
|
|
if (!searchTerm.empty() && mSettingsScrollList->getItemCount())
|
|
mSettingsScrollList->selectFirstItem();
|
|
|
|
onSettingSelect();
|
|
}
|