From a5aeac312c244a38cdef95471bb4cfbccc41aef7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Liru=20F=C3=A6rs?= Date: Thu, 24 Oct 2019 00:25:58 -0400 Subject: [PATCH] Merge debug settings against my updated alchemy version, gain tooltips! --- indra/newview/llfloatersettingsdebug.cpp | 531 ++++++++++++----------- indra/newview/llfloatersettingsdebug.h | 21 +- 2 files changed, 284 insertions(+), 268 deletions(-) diff --git a/indra/newview/llfloatersettingsdebug.cpp b/indra/newview/llfloatersettingsdebug.cpp index aac8e2223..0e775e318 100644 --- a/indra/newview/llfloatersettingsdebug.cpp +++ b/indra/newview/llfloatersettingsdebug.cpp @@ -35,7 +35,6 @@ #include "llfloatersettingsdebug.h" #include "llcolorswatch.h" -//#include "llfirstuse.h" #include "llfloater.h" #include "llscrolllistctrl.h" #include "llscrolllistitem.h" @@ -46,17 +45,21 @@ #include "llviewercontrol.h" #include "llwindow.h" -// [RLVa:KB] - Checked: 2010-03-18 (RLVa-1.2.0a) -#include "rlvhandler.h" -#include "rlvextensions.h" -// [/RLVa:KB] - LLFloaterSettingsDebug::LLFloaterSettingsDebug() : LLFloater(std::string("Configuration Editor")) -, mCurrentControlVariable(NULL) -, mOldControlVariable(NULL) -, mOldSearchTerm(std::string("---")) +, 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)); @@ -69,19 +72,20 @@ LLFloaterSettingsDebug::LLFloaterSettingsDebug() LLFloaterSettingsDebug::~LLFloaterSettingsDebug() { - if (mOldControlVariable) - mOldControlVariable->getCommitSignal()->disconnect(boost::bind(&LLFloaterSettingsDebug::onSettingSelect, this)); + if (mCurrentControlVariable) + mCurrentControlVariable->getCommitSignal()->disconnect(boost::bind(&LLFloaterSettingsDebug::updateControl, this)); } BOOL LLFloaterSettingsDebug::postBuild() { mSettingsScrollList = getChild("settings_scroll_list"); - struct f : public LLControlGroup::ApplyFunctor + struct f final : public LLControlGroup::ApplyFunctor { settings_map_t* map; f(settings_map_t* m) : map(m) {} - virtual void apply(const std::string& name, LLControlVariable* control) + + void apply(const std::string& name, LLControlVariable* control) override final { if (!control->isHiddenFromSettingsEditor()) { @@ -95,26 +99,30 @@ BOOL LLFloaterSettingsDebug::postBuild() gColors.applyToAll(&func); // Populate the list - { - for(settings_map_t::iterator it = mSettingsMap.begin(); it != mSettingsMap.end(); it++) - { - LLSD item; - item["columns"][0]["value"] = it->second->getName(); - mSettingsScrollList->addElement(item, ADD_BOTTOM, it->second); - } - } + for(const auto& pair : mSettingsMap) + addRow(pair.second); + mSettingsScrollList->sortByColumnIndex(0, true); + mComment = getChild("comment_text"); + mValSpinner1 = getChild("val_spinner_1"); + mValSpinner2 = getChild("val_spinner_2"); + mValSpinner3 = getChild("val_spinner_3"); + mValSpinner4 = getChild("val_spinner_4"); + mValColor = getChild("val_color_swatch"); + mValBool = getChild("boolean_combo"); + mValText = getChild("val_text"); + mBtnCopy = getChildView("copy_btn"); + mBtnDefault = getChildView("default_btn"); LL_INFOS() << mSettingsScrollList->getItemCount() << " total debug settings displayed." << LL_ENDL; - mComment = getChild("comment_text"); return TRUE; } void LLFloaterSettingsDebug::draw() { // check for changes in control visibility, like RLVa does - if(mCurrentControlVariable && mCurrentControlVariable->isHiddenFromSettingsEditor() != mOldVisibility) + if (mCurrentControlVariable && mCurrentControlVariable->isHiddenFromSettingsEditor() != mOldVisibility) updateControl(); LLFloater::draw(); @@ -123,36 +131,66 @@ void LLFloaterSettingsDebug::draw() LLControlVariable* LLFloaterSettingsDebug::getControlVariable() { LLScrollListItem* item = mSettingsScrollList->getFirstSelected(); - if (!item) return NULL; + if (!item) return nullptr; LLControlVariable* controlp = static_cast(item->getUserdata()); - return controlp ? controlp->getCOAActive() : NULL; + 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() { - mCurrentControlVariable = getControlVariable(); + auto new_control = getControlVariable(); - if (mOldControlVariable == mCurrentControlVariable) return; + if (new_control == mCurrentControlVariable) return; // unbind change control signal from previously selected control - if(mOldControlVariable) - mOldControlVariable->getCommitSignal()->disconnect(boost::bind(&LLFloaterSettingsDebug::onSettingSelect, this)); + 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::onSettingSelect, this)); - - mOldControlVariable = mCurrentControlVariable; + if (mCurrentControlVariable) + mCurrentControlVariable->getCommitSignal()->connect(boost::bind(&LLFloaterSettingsDebug::updateControl, this)); updateControl(); } void LLFloaterSettingsDebug::onCommitSettings() { - if (!mCurrentControlVariable) + LLControlVariable* controlp = mCurrentControlVariable; + + if (!controlp) + { return; + } LLVector3 vector; LLVector3d vectord; @@ -162,63 +200,63 @@ void LLFloaterSettingsDebug::onCommitSettings() LLColor4U col4U; LLColor4 color_with_alpha; - switch(mCurrentControlVariable->type()) + switch(controlp->type()) { case TYPE_U32: - mCurrentControlVariable->set(getChild("val_spinner_1")->getValue()); + controlp->set(mValSpinner1->getValue()); break; case TYPE_S32: - mCurrentControlVariable->set(getChild("val_spinner_1")->getValue()); + controlp->set(mValSpinner1->getValue()); break; case TYPE_F32: - mCurrentControlVariable->set(LLSD(getChild("val_spinner_1")->getValue().asReal())); + controlp->set(LLSD(mValSpinner1->getValue().asReal())); break; case TYPE_BOOLEAN: - mCurrentControlVariable->set(getChild("boolean_combo")->getValue()); + controlp->set(mValBool->getValue()); break; case TYPE_STRING: - mCurrentControlVariable->set(LLSD(getChild("val_text")->getValue().asString())); + controlp->set(mValText->getValue()); break; case TYPE_VEC3: - vector.mV[VX] = (F32)getChild("val_spinner_1")->getValue().asReal(); - vector.mV[VY] = (F32)getChild("val_spinner_2")->getValue().asReal(); - vector.mV[VZ] = (F32)getChild("val_spinner_3")->getValue().asReal(); - mCurrentControlVariable->set(vector.getValue()); + 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] = getChild("val_spinner_1")->getValue().asReal(); - vectord.mdV[VY] = getChild("val_spinner_2")->getValue().asReal(); - vectord.mdV[VZ] = getChild("val_spinner_3")->getValue().asReal(); - mCurrentControlVariable->set(vectord.getValue()); + 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 = getChild("val_spinner_1")->getValue().asInteger(); - rect.mRight = getChild("val_spinner_2")->getValue().asInteger(); - rect.mBottom = getChild("val_spinner_3")->getValue().asInteger(); - rect.mTop = getChild("val_spinner_4")->getValue().asInteger(); - mCurrentControlVariable->set(rect.getValue()); + 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(getChild("val_color_swatch")->getValue()); - col4 = LLColor4(col3, (F32)getChild("val_spinner_4")->getValue().asReal()); - mCurrentControlVariable->set(col4.getValue()); + col3.setValue(mValColor->getValue()); + col4 = LLColor4(col3, (F32)mValSpinner4->getValue().asReal()); + controlp->set(col4.getValue()); break; case TYPE_COL3: - mCurrentControlVariable->set(getChild("val_color_swatch")->getValue()); - //col3.mV[VRED] = (F32)getChild("val_spinner_1")->getValue().asC(); - //col3.mV[VGREEN] = (F32)getChild("val_spinner_2")->getValue().asReal(); - //col3.mV[VBLUE] = (F32)getChild("val_spinner_3")->getValue().asReal(); + 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(getChild("val_color_swatch")->getValue()); + col3.setValue(mValColor->getValue()); col4U.setVecScaleClamp(col3); - col4U.mV[VALPHA] = getChild("val_spinner_4")->getValue().asInteger(); + col4U.mV[VALPHA] = mValSpinner4->getValue().asInteger(); mCurrentControlVariable->set(col4U.getValue()); break; case TYPE_LLSD: { - auto val = getChild("val_text")->getValue().asString(); + const auto& val = mValText->getValue().asString(); LLSD sd; if (!val.empty()) { @@ -246,164 +284,156 @@ void LLFloaterSettingsDebug::onClickDefault() void LLFloaterSettingsDebug::onCopyToClipboard() { if (mCurrentControlVariable) + { getWindow()->copyTextToClipboard(utf8str_to_wstring(mCurrentControlVariable->getName())); + } } -// we've switched controls, so update spinners, etc. +// we've switched controls, or doing per-frame update, so update spinners, etc. void LLFloaterSettingsDebug::updateControl() { - LLSpinCtrl* spinner1 = getChild("val_spinner_1"); - LLSpinCtrl* spinner2 = getChild("val_spinner_2"); - LLSpinCtrl* spinner3 = getChild("val_spinner_3"); - LLSpinCtrl* spinner4 = getChild("val_spinner_4"); - LLColorSwatchCtrl* color_swatch = getChild("val_color_swatch"); - LLUICtrl* bool_ctrl = getChild("boolean_combo"); - - if (!spinner1 || !spinner2 || !spinner3 || !spinner4 || !color_swatch) + if (!mValSpinner1 || !mValSpinner2 || !mValSpinner3 || !mValSpinner4 || !mValColor) { LL_WARNS() << "Could not find all desired controls by name" << LL_ENDL; return; } - spinner1->setVisible(FALSE); - spinner2->setVisible(FALSE); - spinner3->setVisible(FALSE); - spinner4->setVisible(FALSE); - color_swatch->setVisible(FALSE); - getChildView("val_text")->setVisible( FALSE); - mComment->setText(LLStringUtil::null); - childSetEnabled("copy_btn", false); - childSetEnabled("default_btn", false); - bool_ctrl->setVisible(false); + mValSpinner1->setVisible(FALSE); + mValSpinner2->setVisible(FALSE); + mValSpinner3->setVisible(FALSE); + mValSpinner4->setVisible(FALSE); + mValColor->setVisible(FALSE); + mValText->setVisible(FALSE); + if (!mComment->hasFocus()) // + { + 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(); - spinner1->setEnabled(!mOldVisibility); - spinner2->setEnabled(!mOldVisibility); - spinner3->setEnabled(!mOldVisibility); - spinner4->setEnabled(!mOldVisibility); - color_swatch->setEnabled(!mOldVisibility); - childSetEnabled("val_text", !mOldVisibility); - bool_ctrl->setEnabled(!mOldVisibility); - childSetEnabled("default_btn", !mOldVisibility); + 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] - childSetEnabled("copy_btn", true); + mBtnCopy->setEnabled(true); eControlType type = mCurrentControlVariable->type(); - - mComment->setText(mCurrentControlVariable->getName() + std::string(": ") + mCurrentControlVariable->getComment()); - - spinner1->setMaxValue(F32_MAX); - spinner2->setMaxValue(F32_MAX); - spinner3->setMaxValue(F32_MAX); - spinner4->setMaxValue(F32_MAX); - spinner1->setMinValue(-F32_MAX); - spinner2->setMinValue(-F32_MAX); - spinner3->setMinValue(-F32_MAX); - spinner4->setMinValue(-F32_MAX); - if (!spinner1->hasFocus()) + if (!mComment->hasFocus()) // { - spinner1->setIncrement(0.1f); + mComment->setText(mCurrentControlVariable->getName() + std::string(": ") + mCurrentControlVariable->getComment()); } - if (!spinner2->hasFocus()) + mValSpinner1->setMaxValue(F32_MAX); + mValSpinner2->setMaxValue(F32_MAX); + mValSpinner3->setMaxValue(F32_MAX); + mValSpinner4->setMaxValue(F32_MAX); + mValSpinner1->setMinValue(F32_MIN); + mValSpinner2->setMinValue(F32_MIN); + mValSpinner3->setMinValue(F32_MIN); + mValSpinner4->setMinValue(F32_MIN); + if (!mValSpinner1->hasFocus()) { - spinner2->setIncrement(0.1f); + mValSpinner1->setIncrement(0.1f); } - if (!spinner3->hasFocus()) + if (!mValSpinner2->hasFocus()) { - spinner3->setIncrement(0.1f); + mValSpinner2->setIncrement(0.1f); } - if (!spinner4->hasFocus()) + if (!mValSpinner3->hasFocus()) { - spinner4->setIncrement(0.1f); + mValSpinner3->setIncrement(0.1f); + } + if (!mValSpinner4->hasFocus()) + { + mValSpinner4->setIncrement(0.1f); } LLSD sd = mCurrentControlVariable->get(); switch(type) { case TYPE_U32: - spinner1->setVisible(TRUE); - spinner1->setLabel(std::string("value")); // Debug, don't translate - if (!spinner1->hasFocus()) + mValSpinner1->setVisible(TRUE); + mValSpinner1->setLabel(LLStringExplicit("value")); // Debug, don't translate + if (!mValSpinner1->hasFocus()) { - spinner1->setValue(sd); - spinner1->setMinValue((F32)U32_MIN); - spinner1->setMaxValue((F32)U32_MAX); - spinner1->setIncrement(1.f); - spinner1->setPrecision(0); + mValSpinner1->setValue(sd); + mValSpinner1->setMinValue((F32)U32_MIN); + mValSpinner1->setMaxValue((F32)U32_MAX); + mValSpinner1->setIncrement(1.f); + mValSpinner1->setPrecision(0); } break; case TYPE_S32: - spinner1->setVisible(TRUE); - spinner1->setLabel(std::string("value")); // Debug, don't translate - if (!spinner1->hasFocus()) + mValSpinner1->setVisible(TRUE); + mValSpinner1->setLabel(LLStringExplicit("value")); // Debug, don't translate + if (!mValSpinner1->hasFocus()) { - spinner1->setValue(sd); - spinner1->setMinValue((F32)S32_MIN); - spinner1->setMaxValue((F32)S32_MAX); - spinner1->setIncrement(1.f); - spinner1->setPrecision(0); + mValSpinner1->setValue(sd); + mValSpinner1->setMinValue((F32)S32_MIN); + mValSpinner1->setMaxValue((F32)S32_MAX); + mValSpinner1->setIncrement(1.f); + mValSpinner1->setPrecision(0); } break; case TYPE_F32: - spinner1->setVisible(TRUE); - spinner1->setLabel(std::string("value")); // Debug, don't translate - if (!spinner1->hasFocus()) + mValSpinner1->setVisible(TRUE); + mValSpinner1->setLabel(LLStringExplicit("value")); // Debug, don't translate + if (!mValSpinner1->hasFocus()) { - spinner1->setPrecision(3); - spinner1->setValue(sd); + mValSpinner1->setPrecision(3); + mValSpinner1->setValue(sd); } break; case TYPE_BOOLEAN: - bool_ctrl->setVisible(true); - if (!bool_ctrl->hasFocus()) + mValBool->setVisible(true); + if (!mValBool->hasFocus()) { - if (sd.asBoolean()) - { - bool_ctrl->setValue(LLSD("TRUE")); - } - else - { - bool_ctrl->setValue(LLSD("FALSE")); - } + mValBool->setValue(LLSD(sd.asBoolean() ? "TRUE" : "FALSE")); } break; case TYPE_STRING: - getChildView("val_text")->setVisible( TRUE); - if (!getChild("val_text")->hasFocus()) + mValText->setVisible(TRUE); + if (!mValText->hasFocus()) { - getChild("val_text")->setValue(sd); + mValText->setValue(sd); } break; case TYPE_VEC3: { LLVector3 v; v.setValue(sd); - spinner1->setVisible(TRUE); - spinner1->setLabel(std::string("X")); - spinner2->setVisible(TRUE); - spinner2->setLabel(std::string("Y")); - spinner3->setVisible(TRUE); - spinner3->setLabel(std::string("Z")); - if (!spinner1->hasFocus()) + mValSpinner1->setVisible(TRUE); + mValSpinner1->setLabel(LLStringExplicit("X")); + mValSpinner2->setVisible(TRUE); + mValSpinner2->setLabel(LLStringExplicit("Y")); + mValSpinner3->setVisible(TRUE); + mValSpinner3->setLabel(LLStringExplicit("Z")); + if (!mValSpinner1->hasFocus()) { - spinner1->setPrecision(3); - spinner1->setValue(v[VX]); + mValSpinner1->setPrecision(3); + mValSpinner1->setValue(v[VX]); } - if (!spinner2->hasFocus()) + if (!mValSpinner2->hasFocus()) { - spinner2->setPrecision(3); - spinner2->setValue(v[VY]); + mValSpinner2->setPrecision(3); + mValSpinner2->setValue(v[VY]); } - if (!spinner3->hasFocus()) + if (!mValSpinner3->hasFocus()) { - spinner3->setPrecision(3); - spinner3->setValue(v[VZ]); + mValSpinner3->setPrecision(3); + mValSpinner3->setValue(v[VZ]); } break; } @@ -411,26 +441,26 @@ void LLFloaterSettingsDebug::updateControl() { LLVector3d v; v.setValue(sd); - spinner1->setVisible(TRUE); - spinner1->setLabel(std::string("X")); - spinner2->setVisible(TRUE); - spinner2->setLabel(std::string("Y")); - spinner3->setVisible(TRUE); - spinner3->setLabel(std::string("Z")); - if (!spinner1->hasFocus()) + mValSpinner1->setVisible(TRUE); + mValSpinner1->setLabel(LLStringExplicit("X")); + mValSpinner2->setVisible(TRUE); + mValSpinner2->setLabel(LLStringExplicit("Y")); + mValSpinner3->setVisible(TRUE); + mValSpinner3->setLabel(LLStringExplicit("Z")); + if (!mValSpinner1->hasFocus()) { - spinner1->setPrecision(3); - spinner1->setValue(v[VX]); + mValSpinner1->setPrecision(3); + mValSpinner1->setValue(v[VX]); } - if (!spinner2->hasFocus()) + if (!mValSpinner2->hasFocus()) { - spinner2->setPrecision(3); - spinner2->setValue(v[VY]); + mValSpinner2->setPrecision(3); + mValSpinner2->setValue(v[VY]); } - if (!spinner3->hasFocus()) + if (!mValSpinner3->hasFocus()) { - spinner3->setPrecision(3); - spinner3->setValue(v[VZ]); + mValSpinner3->setPrecision(3); + mValSpinner3->setValue(v[VZ]); } break; } @@ -438,70 +468,70 @@ void LLFloaterSettingsDebug::updateControl() { LLRect r; r.setValue(sd); - spinner1->setVisible(TRUE); - spinner1->setLabel(std::string("Left")); - spinner2->setVisible(TRUE); - spinner2->setLabel(std::string("Right")); - spinner3->setVisible(TRUE); - spinner3->setLabel(std::string("Bottom")); - spinner4->setVisible(TRUE); - spinner4->setLabel(std::string("Top")); - if (!spinner1->hasFocus()) + 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()) { - spinner1->setPrecision(0); - spinner1->setValue(r.mLeft); + mValSpinner1->setPrecision(0); + mValSpinner1->setValue(r.mLeft); } - if (!spinner2->hasFocus()) + if (!mValSpinner2->hasFocus()) { - spinner2->setPrecision(0); - spinner2->setValue(r.mRight); + mValSpinner2->setPrecision(0); + mValSpinner2->setValue(r.mRight); } - if (!spinner3->hasFocus()) + if (!mValSpinner3->hasFocus()) { - spinner3->setPrecision(0); - spinner3->setValue(r.mBottom); + mValSpinner3->setPrecision(0); + mValSpinner3->setValue(r.mBottom); } - if (!spinner4->hasFocus()) + if (!mValSpinner4->hasFocus()) { - spinner4->setPrecision(0); - spinner4->setValue(r.mTop); + mValSpinner4->setPrecision(0); + mValSpinner4->setValue(r.mTop); } - spinner1->setMinValue((F32)S32_MIN); - spinner1->setMaxValue((F32)S32_MAX); - spinner1->setIncrement(1.f); + mValSpinner1->setMinValue((F32)S32_MIN); + mValSpinner1->setMaxValue((F32)S32_MAX); + mValSpinner1->setIncrement(1.f); - spinner2->setMinValue((F32)S32_MIN); - spinner2->setMaxValue((F32)S32_MAX); - spinner2->setIncrement(1.f); + mValSpinner2->setMinValue((F32)S32_MIN); + mValSpinner2->setMaxValue((F32)S32_MAX); + mValSpinner2->setIncrement(1.f); - spinner3->setMinValue((F32)S32_MIN); - spinner3->setMaxValue((F32)S32_MAX); - spinner3->setIncrement(1.f); + mValSpinner3->setMinValue((F32)S32_MIN); + mValSpinner3->setMaxValue((F32)S32_MAX); + mValSpinner3->setIncrement(1.f); - spinner4->setMinValue((F32)S32_MIN); - spinner4->setMaxValue((F32)S32_MAX); - spinner4->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); - color_swatch->setVisible(TRUE); + mValColor->setVisible(TRUE); // only set if changed so color picker doesn't update - if(clr != LLColor4(color_swatch->getValue())) + if(clr != LLColor4(mValColor->getValue())) { - color_swatch->set(LLColor4(sd), TRUE, FALSE); + mValColor->set(LLColor4(sd), TRUE, FALSE); } - spinner4->setVisible(TRUE); - spinner4->setLabel(std::string("Alpha")); - if (!spinner4->hasFocus()) + mValSpinner4->setVisible(TRUE); + mValSpinner4->setLabel(LLStringExplicit("Alpha")); + if (!mValSpinner4->hasFocus()) { - spinner4->setPrecision(3); - spinner4->setMinValue(0.0); - spinner4->setMaxValue(1.f); - spinner4->setValue(clr.mV[VALPHA]); + mValSpinner4->setPrecision(3); + mValSpinner4->setMinValue(0.0); + mValSpinner4->setMaxValue(1.f); + mValSpinner4->setValue(clr.mV[VALPHA]); } break; } @@ -509,43 +539,42 @@ void LLFloaterSettingsDebug::updateControl() { LLColor3 clr; clr.setValue(sd); - color_swatch->setVisible(TRUE); - color_swatch->setValue(sd); + mValColor->setVisible(TRUE); + mValColor->setValue(sd); break; } case TYPE_COL4U: { - LLColor4U clr; - clr.setValue(sd); + LLColor4U clr(sd); color_swatch->setVisible(TRUE); - if(LLColor4(clr) != LLColor4(color_swatch->getValue())) + if (LLColor4(clr) != LLColor4(color_swatch->getValue())) { - color_swatch->set(LLColor4(clr), TRUE, FALSE); + mValColor->set(LLColor4(clr), TRUE, FALSE); } - spinner4->setVisible(TRUE); - spinner4->setLabel(std::string("Alpha")); - if(!spinner4->hasFocus()) + mValSpinner4->setVisible(TRUE); + mValSpinner4->setLabel(std::string("Alpha")); + if(!mValSpinner4->hasFocus()) { - spinner4->setPrecision(0); - spinner4->setValue(clr.mV[VALPHA]); + mValSpinner4->setPrecision(0); + mValSpinner4->setValue(clr.mV[VALPHA]); } - spinner4->setMinValue(0); - spinner4->setMaxValue(255); - spinner4->setIncrement(1.f); + mValSpinner4->setMinValue(0); + mValSpinner4->setMaxValue(255); + mValSpinner4->setIncrement(1.f); break; } case TYPE_LLSD: - getChildView("val_text")->setVisible(true); + mValText->setVisible(true); { std::ostringstream str; LLSDSerialize::toPrettyXML(sd, str); - getChild("val_text")->setValue(str.str()); + mValText->setValue(str.str()); } break; default: - mComment->setText(std::string("unknown")); + mComment->setText(LLStringExplicit("unknown")); break; } } @@ -559,49 +588,23 @@ void LLFloaterSettingsDebug::onUpdateFilter(const LLSD& value) 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; - LLStringUtil::toLower(searchTerm); - mSettingsScrollList->deleteAllItems(); - for(settings_map_t::iterator it = mSettingsMap.begin(); it != mSettingsMap.end(); it++) - { - bool addItem = searchTerm.empty(); - if (!addItem) - { - std::string itemValue = it->second->getName(); + for(const auto& pair : mSettingsMap) + addRow(pair.second, searchTerm); - LLStringUtil::toLower(itemValue); - - if (itemValue.find(searchTerm, 0) != std::string::npos) - { - addItem = true; - } - else // performance: broken out to save toLower calls on comments - { - std::string itemComment = it->second->getComment(); - LLStringUtil::toLower(itemComment); - if (itemComment.find(searchTerm, 0) != std::string::npos) - addItem = true; - } - } - - if (addItem) - { - LLSD item; - item["columns"][0]["value"] = it->second->getName(); - mSettingsScrollList->addElement(item, ADD_BOTTOM, it->second); - } - } 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 (mSettingsScrollList->getItemCount() && !searchTerm.empty()) + if (!searchTerm.empty() && mSettingsScrollList->getItemCount()) mSettingsScrollList->selectFirstItem(); onSettingSelect(); diff --git a/indra/newview/llfloatersettingsdebug.h b/indra/newview/llfloatersettingsdebug.h index 5c94d6bd0..d9fd50e91 100644 --- a/indra/newview/llfloatersettingsdebug.h +++ b/indra/newview/llfloatersettingsdebug.h @@ -36,10 +36,14 @@ #include "llcontrol.h" #include "llfloater.h" +class LLControlVariable; +class LLColorSwatchCtrl; class LLScrollListCtrl; +class LLSpinCtrl; class LLTextEditor; +class LLUICtrl; -class LLFloaterSettingsDebug +class LLFloaterSettingsDebug final : public LLFloater , public LLSingleton { @@ -47,8 +51,8 @@ public: LLFloaterSettingsDebug(); virtual ~LLFloaterSettingsDebug(); - virtual BOOL postBuild(); - virtual void draw(); + BOOL postBuild() override; + void draw() override; void updateControl(); @@ -64,6 +68,7 @@ public: private: // returns a pointer to the currently selected control variable, or NULL LLControlVariable* getControlVariable(); + void addRow(LLControlVariable* control, const std::string& searchTerm = LLStringUtil::null); protected: typedef std::map settings_map_t; @@ -72,11 +77,19 @@ protected: std::string mOldSearchTerm; LLControlVariable* mCurrentControlVariable; - LLControlVariable* mOldControlVariable; bool mOldVisibility; LLScrollListCtrl* mSettingsScrollList; + LLSpinCtrl* mValSpinner1; + LLSpinCtrl* mValSpinner2; + LLSpinCtrl* mValSpinner3; + LLSpinCtrl* mValSpinner4; + LLColorSwatchCtrl* mValColor; + LLUICtrl* mValBool; + LLUICtrl* mValText; LLTextEditor* mComment; + LLView* mBtnCopy; + LLView* mBtnDefault; }; #endif //LLFLOATERDEBUGSETTINGS_H