1878 lines
62 KiB
C++
1878 lines
62 KiB
C++
/**
|
|
* @file quickprefs.cpp
|
|
* @brief Quick preferences access panel for bottomtray
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
* Copyright (C) 2011, WoLf Loonie @ Second Life
|
|
* Copyright (C) 2013, Zi Ree @ Second Life
|
|
* Copyright (C) 2013, Ansariel Hiller @ Second Life
|
|
* Copyright (C) 2013, Cinder Biscuits @ Me too
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "quickprefs.h"
|
|
#include "llboost.h"
|
|
#include "llcombobox.h"
|
|
#include "lldaycyclemanager.h"
|
|
#include "llwlparamset.h"
|
|
#include "llwlparammanager.h"
|
|
#include "llwaterparammanager.h"
|
|
#include "llfloatereditsky.h"
|
|
#include "llmultisliderctrl.h"
|
|
#include "lltimectrl.h"
|
|
#include "llenvmanager.h"
|
|
#include "llviewercontrol.h"
|
|
#include "lldrawpoolbump.h"
|
|
#include "llviewertexturelist.h"
|
|
#include "llfloaterreg.h"
|
|
#include "llfeaturemanager.h"
|
|
#include "rlvhandler.h"
|
|
#include "llcheckboxctrl.h"
|
|
#include "llcubemap.h"
|
|
|
|
// <FS:Zi> Dynamic quick prefs
|
|
#include "llappviewer.h"
|
|
#include "llcolorswatch.h"
|
|
#include "llf32uictrl.h"
|
|
#include "lllayoutstack.h"
|
|
#include "llsliderctrl.h"
|
|
#include "llspinctrl.h"
|
|
#include "llnotificationsutil.h" // <FS:CR> For restore defaults confirmation
|
|
|
|
#include <boost/foreach.hpp>
|
|
#include <llui.h>
|
|
|
|
static F32 sun_pos_to_time24(F32 sun_pos)
|
|
{
|
|
return fmodf(sun_pos * 24.0f + 6, 24.0f);
|
|
}
|
|
|
|
static F32 time24_to_sun_pos(F32 time)
|
|
{
|
|
F32 ret = time - 6.f;
|
|
if (ret < 0)
|
|
{
|
|
ret += 24.f;
|
|
}
|
|
|
|
return (ret / 24.f);
|
|
}
|
|
|
|
|
|
FloaterQuickPrefs::QuickPrefsXML::QuickPrefsXML()
|
|
: entries("entries")
|
|
{}
|
|
|
|
FloaterQuickPrefs::QuickPrefsXMLEntry::QuickPrefsXMLEntry()
|
|
: control_name("control_name"),
|
|
label("label"),
|
|
control_type("control_type"),
|
|
integer("integer"),
|
|
min_value("min"), // "min" is frowned upon by a braindead windows include
|
|
max_value("max"), // "max" see "min"
|
|
increment("increment")
|
|
{}
|
|
// </FS:Zi>
|
|
|
|
FloaterQuickPrefs::FloaterQuickPrefs(const LLSD& key)
|
|
: LLTransientDockableFloater(NULL, true, key),
|
|
mRlvBehaviorCallbackConnection()
|
|
{
|
|
// For Phototools
|
|
mCommitCallbackRegistrar.add("Quickprefs.ShaderChanged", boost::bind(&handleSetShaderChanged, LLSD()));
|
|
}
|
|
|
|
FloaterQuickPrefs::~FloaterQuickPrefs()
|
|
{
|
|
if (mRlvBehaviorCallbackConnection.connected())
|
|
{
|
|
mRlvBehaviorCallbackConnection.disconnect();
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::onOpen(const LLSD& key)
|
|
{
|
|
// <FS:Zi> Dynamic Quickprefs
|
|
|
|
// bail out here if this is a reused Phototools floater
|
|
if(getIsPhototools())
|
|
{
|
|
return;
|
|
}
|
|
|
|
gSavedSettings.setBOOL("QuickPrefsEditMode",FALSE);
|
|
|
|
// Scan widgets and reapply control variables because some control types
|
|
// (LLSliderCtrl for example) don't update their GUI when hidden
|
|
control_list_t::iterator it;
|
|
for(it=mControlsList.begin();it!=mControlsList.end();++it)
|
|
{
|
|
const ControlEntry& entry=it->second;
|
|
|
|
LLUICtrl* current_widget=entry.widget;
|
|
if(!current_widget)
|
|
{
|
|
LL_WARNS() << "missing widget for control " << it->first << LL_ENDL;
|
|
continue;
|
|
}
|
|
|
|
LLControlVariable* var=current_widget->getControlVariable();
|
|
if(var)
|
|
{
|
|
current_widget->setValue(var->getValue());
|
|
}
|
|
}
|
|
// </FS:Zi>
|
|
}
|
|
|
|
|
|
void FloaterQuickPrefs::initCallbacks()
|
|
{
|
|
getChild<LLUICtrl>("UseRegionWindlight")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeUseRegionWindlight, this));
|
|
getChild<LLUICtrl>("WaterPresetsCombo")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeWaterPreset, this));
|
|
getChild<LLUICtrl>("WLPresetsCombo")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeSkyPreset, this));
|
|
getChild<LLUICtrl>("DCPresetsCombo")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeDayCyclePreset, this));
|
|
getChild<LLUICtrl>("WLPrevPreset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickSkyPrev, this));
|
|
getChild<LLUICtrl>("WLNextPreset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickSkyNext, this));
|
|
getChild<LLUICtrl>("WWPrevPreset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickWaterPrev, this));
|
|
getChild<LLUICtrl>("WWNextPreset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickWaterNext, this));
|
|
getChild<LLUICtrl>("DCPrevPreset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickDayCyclePrev, this));
|
|
getChild<LLUICtrl>("DCNextPreset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickDayCycleNext, this));
|
|
getChild<LLUICtrl>("ResetToRegionDefault")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetToRegionDefault, this));
|
|
getChild<LLUICtrl>("WLSunPos")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onSunMoved, this));
|
|
|
|
// Phototools additions
|
|
if (getIsPhototools())
|
|
{
|
|
gSavedSettings.getControl("VertexShaderEnable")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("WindLightUseAtmosShaders")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("RenderDeferred")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("RenderAvatarVP")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("RenderShadowDetail")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("FSRenderVignette")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("RenderShadowSplitExponent")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("RenderShadowGaussian")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
gSavedSettings.getControl("RenderSSAOEffect")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::refreshSettings, this));
|
|
|
|
// <FS:CR> FIRE-9630 - Vignette UI controls
|
|
getChild<LLSpinCtrl>("VignetteSpinnerX")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeVignetteSpinnerX, this));
|
|
getChild<LLSlider>("VignetteSliderX")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeVignetteX, this));
|
|
getChild<LLButton>("Reset_VignetteX")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetVignetteX, this));
|
|
getChild<LLSpinCtrl>("VignetteSpinnerY")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeVignetteSpinnerY, this));
|
|
getChild<LLSlider>("VignetteSliderY")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeVignetteY, this));
|
|
getChild<LLButton>("Reset_VignetteY")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetVignetteY, this));
|
|
getChild<LLSpinCtrl>("VignetteSpinnerZ")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeVignetteSpinnerZ, this));
|
|
getChild<LLSlider>("VignetteSliderZ")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeVignetteZ, this));
|
|
getChild<LLButton>("Reset_VignetteZ")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetVignetteZ, this));
|
|
// </FS:CR>
|
|
|
|
getChild<LLSlider>("SB_Shd_Clarity")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderShadowSplitExponentSlider, this));
|
|
getChild<LLSpinCtrl>("S_Shd_Clarity")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderShadowSplitExponentSpinner, this));
|
|
getChild<LLButton>("Shd_Clarity_Reset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetRenderShadowSplitExponentY, this));
|
|
|
|
getChild<LLSlider>("SB_Shd_Soften")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderShadowGaussianSlider, this));
|
|
getChild<LLSlider>("SB_AO_Soften")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderShadowGaussianSlider, this));
|
|
getChild<LLSpinCtrl>("S_Shd_Soften")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderShadowGaussianSpinner, this));
|
|
getChild<LLSpinCtrl>("S_AO_Soften")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderShadowGaussianSpinner, this));
|
|
getChild<LLButton>("Shd_Soften_Reset")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetRenderShadowGaussianX, this));
|
|
getChild<LLButton>("Reset_AO_Soften")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetRenderShadowGaussianY, this));
|
|
|
|
getChild<LLSlider>("SB_Effect")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderSSAOEffectSlider, this));
|
|
getChild<LLSpinCtrl>("S_Effect")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onChangeRenderSSAOEffectSpinner, this));
|
|
getChild<LLButton>("Reset_Effect")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickResetRenderSSAOEffectX, this));
|
|
}
|
|
else
|
|
{
|
|
getChild<LLButton>("Restore_Btn")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onClickRestoreDefaults, this));
|
|
gSavedSettings.getControl("QuickPrefsEditMode")->getSignal()->connect(boost::bind(&FloaterQuickPrefs::onEditModeChanged, this)); // <FS:Zi> Dynamic Quickprefs
|
|
}
|
|
|
|
mRlvBehaviorCallbackConnection = gRlvHandler.setBehaviourCallback(boost::bind(&FloaterQuickPrefs::updateRlvRestrictions, this, _1, _2));
|
|
}
|
|
|
|
void FloaterQuickPrefs::loadPresets()
|
|
{
|
|
// WL Water combo box
|
|
if (mWaterPresetsCombo != NULL)
|
|
{
|
|
std::list<std::string> user_presets, system_presets;
|
|
LLWaterParamManager::instance().getPresetNames(user_presets, system_presets);
|
|
|
|
mWaterPresetsCombo->add(LLTrans::getString("QP_WL_Region_Default"), LLSD(PRESET_NAME_REGION_DEFAULT));
|
|
mWaterPresetsCombo->addSeparator();
|
|
|
|
// Add user presets first.
|
|
for (std::list<std::string>::const_iterator mIt = user_presets.begin(); mIt != user_presets.end(); ++mIt)
|
|
{
|
|
std::string preset_name = *mIt;
|
|
if (!preset_name.empty())
|
|
{
|
|
mWaterPresetsCombo->add(preset_name, LLSD(preset_name));
|
|
}
|
|
}
|
|
|
|
if (user_presets.size() > 0)
|
|
{
|
|
mWaterPresetsCombo->addSeparator();
|
|
}
|
|
|
|
// Add system presets.
|
|
for (std::list<std::string>::const_iterator mIt = system_presets.begin(); mIt != system_presets.end(); ++mIt)
|
|
{
|
|
std::string preset_name = *mIt;
|
|
if (!preset_name.empty())
|
|
{
|
|
mWaterPresetsCombo->add(preset_name, LLSD(preset_name));
|
|
}
|
|
}
|
|
}
|
|
|
|
// WL Sky combo box
|
|
if (mWLPresetsCombo != NULL)
|
|
{
|
|
LLWLParamManager::preset_name_list_t user_presets, sys_presets, region_presets;
|
|
LLWLParamManager::instance().getPresetNames(region_presets, user_presets, sys_presets);
|
|
|
|
mWLPresetsCombo->add(LLTrans::getString("QP_WL_Region_Default"), LLSD(PRESET_NAME_REGION_DEFAULT));
|
|
mWLPresetsCombo->add(LLTrans::getString("QP_WL_Day_Cycle_Based"), LLSD(PRESET_NAME_SKY_DAY_CYCLE));
|
|
mWLPresetsCombo->addSeparator();
|
|
|
|
// Add user presets.
|
|
for (LLWLParamManager::preset_name_list_t::const_iterator it = user_presets.begin(); it != user_presets.end(); ++it)
|
|
{
|
|
std::string preset_name = *it;
|
|
if (!preset_name.empty())
|
|
{
|
|
mWLPresetsCombo->add(preset_name, LLSD(preset_name));
|
|
}
|
|
}
|
|
|
|
if (!user_presets.empty())
|
|
{
|
|
mWLPresetsCombo->addSeparator();
|
|
}
|
|
|
|
// Add system presets.
|
|
for (LLWLParamManager::preset_name_list_t::const_iterator it = sys_presets.begin(); it != sys_presets.end(); ++it)
|
|
{
|
|
std::string preset_name = *it;
|
|
if (!preset_name.empty())
|
|
{
|
|
mWLPresetsCombo->add(preset_name, LLSD(preset_name));
|
|
}
|
|
}
|
|
}
|
|
|
|
// WL Day Cycle combo box
|
|
if (mWLPresetsCombo != NULL)
|
|
{
|
|
LLDayCycleManager::preset_name_list_t user_presets, sys_presets;
|
|
LLDayCycleManager::instance().getPresetNames(user_presets, sys_presets);
|
|
|
|
mDayCyclePresetsCombo->add(LLTrans::getString("QP_WL_Region_Default"), LLSD(PRESET_NAME_REGION_DEFAULT));
|
|
mDayCyclePresetsCombo->add(LLTrans::getString("QP_WL_None"), LLSD(PRESET_NAME_NONE));
|
|
mDayCyclePresetsCombo->addSeparator();
|
|
|
|
// Add user presets.
|
|
for (LLDayCycleManager::preset_name_list_t::const_iterator it = user_presets.begin(); it != user_presets.end(); ++it)
|
|
{
|
|
std::string preset_name = *it;
|
|
if (!preset_name.empty())
|
|
{
|
|
mDayCyclePresetsCombo->add(preset_name, LLSD(preset_name));
|
|
}
|
|
}
|
|
|
|
if (!user_presets.empty())
|
|
{
|
|
mDayCyclePresetsCombo->addSeparator();
|
|
}
|
|
|
|
// Add system presets.
|
|
for (LLDayCycleManager::preset_name_list_t::const_iterator it = sys_presets.begin(); it != sys_presets.end(); ++it)
|
|
{
|
|
std::string preset_name = *it;
|
|
if (!preset_name.empty())
|
|
{
|
|
mDayCyclePresetsCombo->add(preset_name, LLSD(preset_name));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL FloaterQuickPrefs::postBuild()
|
|
{
|
|
// Phototools additions
|
|
if (getIsPhototools())
|
|
{
|
|
mCtrlShaderEnable = getChild<LLCheckBoxCtrl>("BasicShaders");
|
|
mCtrlWindLight = getChild<LLCheckBoxCtrl>("WindLightUseAtmosShaders");
|
|
mCtrlDeferred = getChild<LLCheckBoxCtrl>("RenderDeferred");
|
|
mCtrlUseSSAO = getChild<LLCheckBoxCtrl>("UseSSAO");
|
|
mCtrlUseDoF = getChild<LLCheckBoxCtrl>("UseDepthofField");
|
|
mCtrlShadowDetail = getChild<LLComboBox>("ShadowDetail");
|
|
mCtrlReflectionDetail = getChild<LLComboBox>("Reflections");
|
|
// <FS:CR> FIRE-9630 - Vignette UI controls
|
|
mSpinnerVignetteX = getChild<LLSpinCtrl>("VignetteSpinnerX");
|
|
mSpinnerVignetteY = getChild<LLSpinCtrl>("VignetteSpinnerY");
|
|
mSpinnerVignetteZ = getChild<LLSpinCtrl>("VignetteSpinnerZ");
|
|
mSliderVignetteX = getChild<LLSlider>("VignetteSliderX");
|
|
mSliderVignetteY = getChild<LLSlider>("VignetteSliderY");
|
|
mSliderVignetteZ = getChild<LLSlider>("VignetteSliderZ");
|
|
// </FS:CR>
|
|
mSliderRenderShadowSplitExponentY = getChild<LLSlider>("SB_Shd_Clarity");
|
|
mSpinnerRenderShadowSplitExponentY = getChild<LLSpinCtrl>("S_Shd_Clarity");
|
|
|
|
mSliderRenderShadowGaussianX = getChild<LLSlider>("SB_Shd_Soften");
|
|
mSliderRenderShadowGaussianY = getChild<LLSlider>("SB_AO_Soften");
|
|
mSpinnerRenderShadowGaussianX = getChild<LLSpinCtrl>("S_Shd_Soften");
|
|
mSpinnerRenderShadowGaussianY = getChild<LLSpinCtrl>("S_AO_Soften");
|
|
|
|
mSliderRenderSSAOEffectX = getChild<LLSlider>("SB_Effect");
|
|
mSpinnerRenderSSAOEffectX = getChild<LLSpinCtrl>("S_Effect");
|
|
|
|
refreshSettings();
|
|
}
|
|
else
|
|
{
|
|
mBtnResetDefaults = getChild<LLButton>("Restore_Btn");
|
|
}
|
|
|
|
mWaterPresetsCombo = getChild<LLComboBox>("WaterPresetsCombo");
|
|
mWLPresetsCombo = getChild<LLComboBox>("WLPresetsCombo");
|
|
mDayCyclePresetsCombo = getChild<LLComboBox>("DCPresetsCombo");
|
|
mWLSunPos = getChild<LLMultiSliderCtrl>("WLSunPos");
|
|
mUseRegionWindlight = getChild<LLCheckBoxCtrl>("UseRegionWindlight");
|
|
mWLSunPos->addSlider(12.f);
|
|
|
|
initCallbacks();
|
|
loadPresets();
|
|
|
|
if (gRlvHandler.isEnabled())
|
|
{
|
|
enableWindlightButtons(!gRlvHandler.hasBehaviour(RLV_BHVR_SETENV));
|
|
}
|
|
|
|
// <FS:Zi> Dynamic quick prefs
|
|
|
|
// bail out here if this is a reused Phototools floater
|
|
if(getIsPhototools())
|
|
{
|
|
return LLDockableFloater::postBuild();
|
|
}
|
|
|
|
// find the layout_stack to insert the controls into
|
|
mOptionsStack=getChild<LLLayoutStack>("options_stack");
|
|
|
|
// get the path to the user defined or default quick preferences settings
|
|
loadSavedSettingsFromFile(getSettingsPath(FALSE));
|
|
|
|
// get edit widget pointers
|
|
mControlLabelEdit=getChild<LLLineEditor>("label_edit");
|
|
mControlNameCombo=getChild<LLComboBox>("control_name_combo");
|
|
mControlTypeCombo=getChild<LLComboBox>("control_type_combo_box");
|
|
mControlIntegerCheckbox=getChild<LLCheckBoxCtrl>("control_integer_checkbox");
|
|
mControlMinSpinner=getChild<LLSpinCtrl>("control_min_edit");
|
|
mControlMaxSpinner=getChild<LLSpinCtrl>("control_max_edit");
|
|
mControlIncrementSpinner=getChild<LLSpinCtrl>("control_increment_edit");
|
|
|
|
// wire up callbacks for changed values
|
|
mControlLabelEdit->setCommitCallback(boost::bind(&FloaterQuickPrefs::onValuesChanged,this));
|
|
mControlNameCombo->setCommitCallback(boost::bind(&FloaterQuickPrefs::onValuesChanged,this));
|
|
mControlTypeCombo->setCommitCallback(boost::bind(&FloaterQuickPrefs::onValuesChanged,this));
|
|
mControlIntegerCheckbox->setCommitCallback(boost::bind(&FloaterQuickPrefs::onValuesChanged,this));
|
|
mControlMinSpinner->setCommitCallback(boost::bind(&FloaterQuickPrefs::onValuesChanged,this));
|
|
mControlMaxSpinner->setCommitCallback(boost::bind(&FloaterQuickPrefs::onValuesChanged,this));
|
|
mControlIncrementSpinner->setCommitCallback(boost::bind(&FloaterQuickPrefs::onValuesChanged,this));
|
|
|
|
// wire up ordering and adding buttons
|
|
getChild<LLButton>("move_up_button")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onMoveUpClicked,this));
|
|
getChild<LLButton>("move_down_button")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onMoveDownClicked,this));
|
|
getChild<LLButton>("add_new_button")->setCommitCallback(boost::bind(&FloaterQuickPrefs::onAddNewClicked,this));
|
|
|
|
// functor to add debug settings to the editor dropdown
|
|
struct f : public LLControlGroup::ApplyFunctor
|
|
{
|
|
LLComboBox* combo;
|
|
f(LLComboBox* c) : combo(c) {}
|
|
virtual void apply(const std::string& name, LLControlVariable* control)
|
|
{
|
|
// do not add things that are hidden in the debug settings floater
|
|
if (!control->isHiddenFromSettingsEditor())
|
|
{
|
|
// don't add floater positions, sizes or visibility values
|
|
if(name.find("floater_")!=0)
|
|
{
|
|
(*combo).addSimpleElement(name);
|
|
}
|
|
}
|
|
}
|
|
} func(mControlNameCombo);
|
|
|
|
// add global and per account settings to the dropdown
|
|
gSavedSettings.applyToAll(&func);
|
|
gSavedPerAccountSettings.applyToAll(&func);
|
|
mControlNameCombo->sortByName();
|
|
// </FS:Zi>
|
|
|
|
return LLDockableFloater::postBuild();
|
|
}
|
|
|
|
void FloaterQuickPrefs::loadSavedSettingsFromFile(const std::string& settings_path)
|
|
{
|
|
QuickPrefsXML xml;
|
|
LLXMLNodePtr root;
|
|
|
|
if(!LLXMLNode::parseFile(settings_path,root,NULL))
|
|
{
|
|
LL_WARNS() << "Unable to load quick preferences from file: " << settings_path << LL_ENDL;
|
|
}
|
|
else if(!root->hasName("quickprefs"))
|
|
{
|
|
LL_WARNS() << settings_path << " is not a valid quick preferences definition file" << LL_ENDL;
|
|
}
|
|
else
|
|
{
|
|
// Parse the quick preferences settings
|
|
LLXUIParser parser;
|
|
parser.readXUI(root,xml,settings_path);
|
|
|
|
if(!xml.validateBlock())
|
|
{
|
|
LL_WARNS() << "Unable to validate quick preferences from file: " << settings_path << LL_ENDL;
|
|
}
|
|
else
|
|
{
|
|
// add the elements from the XML file to the internal list of controls
|
|
BOOST_FOREACH(const QuickPrefsXMLEntry& xml_entry,xml.entries)
|
|
{
|
|
// get the label
|
|
std::string label=xml_entry.label;
|
|
// get the same as translated label
|
|
std::string translated_label=xml_entry.label;
|
|
// replace translated label with translated version, if available
|
|
LLTrans::findString(translated_label,"QP "+label);
|
|
|
|
U32 type=xml_entry.control_type;
|
|
addControl(
|
|
xml_entry.control_name,
|
|
translated_label,
|
|
NULL,
|
|
(ControlType) type,
|
|
xml_entry.integer,
|
|
xml_entry.min_value,
|
|
xml_entry.max_value,
|
|
xml_entry.increment
|
|
);
|
|
// put it at the bottom of the ordering stack
|
|
mControlsOrder.push_back(xml_entry.control_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool FloaterQuickPrefs::isValidPresetName(const std::string& preset_name)
|
|
{
|
|
return (!preset_name.empty() &&
|
|
preset_name != PRESET_NAME_REGION_DEFAULT &&
|
|
preset_name != PRESET_NAME_SKY_DAY_CYCLE &&
|
|
preset_name != PRESET_NAME_NONE);
|
|
}
|
|
|
|
std::string FloaterQuickPrefs::stepComboBox(LLComboBox* ctrl, bool forward)
|
|
{
|
|
S32 increment = (forward ? 1 : -1);
|
|
S32 lastitem = ctrl->getItemCount() - 1;
|
|
S32 curid = ctrl->getCurrentIndex();
|
|
std::string preset_name;
|
|
std::string start_preset_name;
|
|
|
|
start_preset_name = ctrl->getSelectedValue().asString();
|
|
do
|
|
{
|
|
curid += increment;
|
|
if (curid < 0)
|
|
{
|
|
curid = lastitem;
|
|
}
|
|
else if (curid > lastitem)
|
|
{
|
|
curid = 0;
|
|
}
|
|
ctrl->setCurrentByIndex(curid);
|
|
preset_name = ctrl->getSelectedValue().asString();
|
|
}
|
|
while (!isValidPresetName(preset_name) && preset_name != start_preset_name);
|
|
|
|
return preset_name;
|
|
}
|
|
|
|
void FloaterQuickPrefs::selectSkyPreset(const std::string& preset_name)
|
|
{
|
|
if (isValidPresetName(preset_name))
|
|
{
|
|
deactivateAnimator();
|
|
LLEnvManagerNew::instance().setUseSkyPreset(preset_name, (bool)gSavedSettings.getBOOL("FSInterpolateSky"));
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::selectWaterPreset(const std::string& preset_name)
|
|
{
|
|
if (isValidPresetName(preset_name))
|
|
{
|
|
deactivateAnimator();
|
|
LLEnvManagerNew::instance().setUseWaterPreset(preset_name, (bool)gSavedSettings.getBOOL("FSInterpolateWater"));
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::selectDayCyclePreset(const std::string& preset_name)
|
|
{
|
|
if (isValidPresetName(preset_name))
|
|
{
|
|
deactivateAnimator();
|
|
LLEnvManagerNew::instance().setUseDayCycle(preset_name, (bool)gSavedSettings.getBOOL("FSInterpolateSky"));
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeUseRegionWindlight()
|
|
{
|
|
LLEnvManagerNew &envmgr = LLEnvManagerNew::instance();
|
|
// reset all environmental settings to track the region defaults, make this reset 'sticky' like the other sun settings.
|
|
bool use_fixed_sky = !mUseRegionWindlight->get();
|
|
bool use_region_settings = !use_fixed_sky;
|
|
envmgr.setUserPrefs(envmgr.getWaterPresetName(),
|
|
envmgr.getSkyPresetName(),
|
|
envmgr.getDayCycleName(),
|
|
use_fixed_sky, use_region_settings,
|
|
(gSavedSettings.getBOOL("FSInterpolateSky") || gSavedSettings.getBOOL("FSInterpolateWater")));
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeWaterPreset()
|
|
{
|
|
std::string preset_name = mWaterPresetsCombo->getSelectedValue().asString();
|
|
if (!isValidPresetName(preset_name))
|
|
{
|
|
preset_name = stepComboBox(mWaterPresetsCombo, true);
|
|
}
|
|
selectWaterPreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeSkyPreset()
|
|
{
|
|
std::string preset_name = mWLPresetsCombo->getSelectedValue().asString();
|
|
if (!isValidPresetName(preset_name))
|
|
{
|
|
preset_name = stepComboBox(mWLPresetsCombo, true);
|
|
}
|
|
selectSkyPreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeDayCyclePreset()
|
|
{
|
|
std::string preset_name = mDayCyclePresetsCombo->getSelectedValue().asString();
|
|
if (!isValidPresetName(preset_name))
|
|
{
|
|
preset_name = stepComboBox(mDayCyclePresetsCombo, true);
|
|
}
|
|
selectDayCyclePreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::deactivateAnimator()
|
|
{
|
|
LLWLParamManager::instance().mAnimator.deactivate();
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickWaterPrev()
|
|
{
|
|
std::string preset_name = stepComboBox(mWaterPresetsCombo, false);
|
|
selectWaterPreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickWaterNext()
|
|
{
|
|
std::string preset_name = stepComboBox(mWaterPresetsCombo, true);
|
|
selectWaterPreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickSkyPrev()
|
|
{
|
|
std::string preset_name = stepComboBox(mWLPresetsCombo, false);
|
|
selectSkyPreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickSkyNext()
|
|
{
|
|
std::string preset_name = stepComboBox(mWLPresetsCombo, true);
|
|
selectSkyPreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickDayCyclePrev()
|
|
{
|
|
std::string preset_name = stepComboBox(mDayCyclePresetsCombo, false);
|
|
selectDayCyclePreset(preset_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickDayCycleNext()
|
|
{
|
|
std::string preset_name = stepComboBox(mDayCyclePresetsCombo, true);
|
|
selectDayCyclePreset(preset_name);
|
|
}
|
|
|
|
|
|
void FloaterQuickPrefs::draw()
|
|
{
|
|
F32 val;
|
|
|
|
if (LLEnvManagerNew::instance().getUseRegionSettings() ||
|
|
LLEnvManagerNew::instance().getUseDayCycle())
|
|
{
|
|
val = (F32)(LLWLParamManager::instance().mAnimator.getDayTime() * 24.f);
|
|
}
|
|
else
|
|
{
|
|
val = sun_pos_to_time24(LLWLParamManager::instance().mCurParams.getSunAngle() / F_TWO_PI);
|
|
}
|
|
|
|
mWLSunPos->setCurSliderValue(val);
|
|
|
|
LLFloater::draw();
|
|
}
|
|
|
|
void FloaterQuickPrefs::onSunMoved()
|
|
{
|
|
if (LLEnvManagerNew::instance().getUseRegionSettings() ||
|
|
LLEnvManagerNew::instance().getUseDayCycle())
|
|
{
|
|
F32 val = mWLSunPos->getCurSliderValue() / 24.0f;
|
|
|
|
LLWLParamManager& mgr = LLWLParamManager::instance();
|
|
mgr.mAnimator.setDayTime((F64)val);
|
|
mgr.mAnimator.deactivate();
|
|
mgr.mAnimator.update(mgr.mCurParams);
|
|
}
|
|
else
|
|
{
|
|
deactivateAnimator();
|
|
F32 val = time24_to_sun_pos(mWLSunPos->getCurSliderValue()) * F_TWO_PI;
|
|
LLWLParamManager::instance().mCurParams.setSunAngle(val);
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetToRegionDefault()
|
|
{
|
|
deactivateAnimator();
|
|
LLWLParamManager::instance().mAnimator.stopInterpolation();
|
|
LLEnvManagerNew::instance().useRegionSettings();
|
|
}
|
|
|
|
// This method is invoked by LLEnvManagerNew when a particular preset is applied
|
|
// static
|
|
void FloaterQuickPrefs::updateParam(EQuickPrefUpdateParam param, const LLSD& value)
|
|
{
|
|
FloaterQuickPrefs* qp_floater = LLFloaterReg::getTypedInstance<FloaterQuickPrefs>("quickprefs");
|
|
FloaterQuickPrefs* pt_floater = LLFloaterReg::getTypedInstance<FloaterQuickPrefs>(PHOTOTOOLS_FLOATER);
|
|
|
|
switch (param)
|
|
{
|
|
case QP_PARAM_SKY:
|
|
qp_floater->setSelectedSky(value.asString());
|
|
pt_floater->setSelectedSky(value.asString());
|
|
break;
|
|
case QP_PARAM_WATER:
|
|
qp_floater->setSelectedWater(value.asString());
|
|
pt_floater->setSelectedWater(value.asString());
|
|
break;
|
|
case QP_PARAM_DAYCYCLE:
|
|
qp_floater->setSelectedDayCycle(value.asString());
|
|
pt_floater->setSelectedDayCycle(value.asString());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void FloaterQuickPrefs::setSelectedSky(const std::string& preset_name)
|
|
{
|
|
mWLPresetsCombo->setValue(LLSD(preset_name));
|
|
mDayCyclePresetsCombo->setValue(LLSD(PRESET_NAME_NONE));
|
|
}
|
|
|
|
void FloaterQuickPrefs::setSelectedWater(const std::string& preset_name)
|
|
{
|
|
mWaterPresetsCombo->setValue(LLSD(preset_name));
|
|
}
|
|
|
|
void FloaterQuickPrefs::setSelectedDayCycle(const std::string& preset_name)
|
|
{
|
|
mDayCyclePresetsCombo->setValue(LLSD(preset_name));
|
|
mWLPresetsCombo->setValue(LLSD(PRESET_NAME_SKY_DAY_CYCLE));
|
|
}
|
|
|
|
// Phototools additions
|
|
void FloaterQuickPrefs::refreshSettings()
|
|
{
|
|
BOOL reflections = gSavedSettings.getBOOL("VertexShaderEnable")
|
|
&& gGLManager.mHasCubeMap
|
|
&& LLCubeMap::sUseCubeMaps;
|
|
mCtrlReflectionDetail->setEnabled(reflections);
|
|
|
|
bool fCtrlShaderEnable = LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable");
|
|
mCtrlShaderEnable->setEnabled(
|
|
fCtrlShaderEnable && ((!gRlvHandler.hasBehaviour(RLV_BHVR_SETENV)) || (!gSavedSettings.getBOOL("VertexShaderEnable"))) );
|
|
BOOL shaders = mCtrlShaderEnable->get();
|
|
|
|
bool fCtrlWindLightEnable = fCtrlShaderEnable && shaders;
|
|
mCtrlWindLight->setEnabled(
|
|
fCtrlWindLightEnable && ((!gRlvHandler.hasBehaviour(RLV_BHVR_SETENV)) || (!gSavedSettings.getBOOL("WindLightUseAtmosShaders"))) );
|
|
|
|
BOOL enabled = LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred") &&
|
|
shaders &&
|
|
gGLManager.mHasFramebufferObject &&
|
|
gSavedSettings.getBOOL("RenderAvatarVP") &&
|
|
(mCtrlWindLight->get()) ? TRUE : FALSE;
|
|
|
|
mCtrlDeferred->setEnabled(enabled);
|
|
|
|
enabled = enabled && LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferredSSAO") && (mCtrlDeferred->get() ? TRUE : FALSE);
|
|
|
|
mCtrlUseSSAO->setEnabled(enabled);
|
|
mCtrlUseDoF->setEnabled(enabled);
|
|
|
|
enabled = enabled && LLFeatureManager::getInstance()->isFeatureAvailable("RenderShadowDetail");
|
|
|
|
mCtrlShadowDetail->setEnabled(enabled);
|
|
|
|
|
|
// if vertex shaders off, disable all shader related products
|
|
if (!LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable"))
|
|
{
|
|
mCtrlShaderEnable->setEnabled(FALSE);
|
|
mCtrlShaderEnable->setValue(FALSE);
|
|
|
|
mCtrlWindLight->setEnabled(FALSE);
|
|
mCtrlWindLight->setValue(FALSE);
|
|
|
|
mCtrlReflectionDetail->setEnabled(FALSE);
|
|
mCtrlReflectionDetail->setValue(0);
|
|
|
|
mCtrlShadowDetail->setEnabled(FALSE);
|
|
mCtrlShadowDetail->setValue(0);
|
|
|
|
mCtrlUseSSAO->setEnabled(FALSE);
|
|
mCtrlUseSSAO->setValue(FALSE);
|
|
|
|
mCtrlUseDoF->setEnabled(FALSE);
|
|
mCtrlUseDoF->setValue(FALSE);
|
|
|
|
mCtrlDeferred->setEnabled(FALSE);
|
|
mCtrlDeferred->setValue(FALSE);
|
|
}
|
|
|
|
// disabled windlight
|
|
if (!LLFeatureManager::getInstance()->isFeatureAvailable("WindLightUseAtmosShaders"))
|
|
{
|
|
mCtrlWindLight->setEnabled(FALSE);
|
|
mCtrlWindLight->setValue(FALSE);
|
|
|
|
//deferred needs windlight, disable deferred
|
|
mCtrlShadowDetail->setEnabled(FALSE);
|
|
mCtrlShadowDetail->setValue(0);
|
|
|
|
mCtrlUseSSAO->setEnabled(FALSE);
|
|
mCtrlUseSSAO->setValue(FALSE);
|
|
|
|
mCtrlUseDoF->setEnabled(FALSE);
|
|
mCtrlUseDoF->setValue(FALSE);
|
|
|
|
mCtrlDeferred->setEnabled(FALSE);
|
|
mCtrlDeferred->setValue(FALSE);
|
|
}
|
|
|
|
// disabled deferred
|
|
if (!LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred") ||
|
|
!gGLManager.mHasFramebufferObject)
|
|
{
|
|
mCtrlShadowDetail->setEnabled(FALSE);
|
|
mCtrlShadowDetail->setValue(0);
|
|
|
|
mCtrlUseSSAO->setEnabled(FALSE);
|
|
mCtrlUseSSAO->setValue(FALSE);
|
|
|
|
mCtrlUseDoF->setEnabled(FALSE);
|
|
mCtrlUseDoF->setValue(FALSE);
|
|
|
|
mCtrlDeferred->setEnabled(FALSE);
|
|
mCtrlDeferred->setValue(FALSE);
|
|
}
|
|
|
|
// disabled deferred SSAO
|
|
if (!LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferredSSAO"))
|
|
{
|
|
mCtrlUseSSAO->setEnabled(FALSE);
|
|
mCtrlUseSSAO->setValue(FALSE);
|
|
}
|
|
|
|
// disabled deferred shadows
|
|
if (!LLFeatureManager::getInstance()->isFeatureAvailable("RenderShadowDetail"))
|
|
{
|
|
mCtrlShadowDetail->setEnabled(FALSE);
|
|
mCtrlShadowDetail->setValue(0);
|
|
}
|
|
|
|
// disabled reflections
|
|
if (!LLFeatureManager::getInstance()->isFeatureAvailable("RenderReflectionDetail"))
|
|
{
|
|
mCtrlReflectionDetail->setEnabled(FALSE);
|
|
mCtrlReflectionDetail->setValue(FALSE);
|
|
}
|
|
|
|
// disabled av
|
|
if (!LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP"))
|
|
{
|
|
//deferred needs AvatarVP, disable deferred
|
|
mCtrlShadowDetail->setEnabled(FALSE);
|
|
mCtrlShadowDetail->setValue(0);
|
|
|
|
mCtrlUseSSAO->setEnabled(FALSE);
|
|
mCtrlUseSSAO->setValue(FALSE);
|
|
|
|
mCtrlUseDoF->setEnabled(FALSE);
|
|
mCtrlUseDoF->setValue(FALSE);
|
|
|
|
mCtrlDeferred->setEnabled(FALSE);
|
|
mCtrlDeferred->setValue(FALSE);
|
|
}
|
|
|
|
// <FS:CR> FIRE-9630 - Vignette UI controls
|
|
if (getIsPhototools())
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
mSpinnerVignetteX->setValue(vignette.mV[VX]);
|
|
mSpinnerVignetteY->setValue(vignette.mV[VY]);
|
|
mSpinnerVignetteZ->setValue(vignette.mV[VZ]);
|
|
mSliderVignetteX->setValue(vignette.mV[VX]);
|
|
mSliderVignetteY->setValue(vignette.mV[VY]);
|
|
mSliderVignetteZ->setValue(vignette.mV[VZ]);
|
|
|
|
LLVector3 renderShadowSplitExponent = gSavedSettings.getVector3("RenderShadowSplitExponent");
|
|
mSpinnerRenderShadowSplitExponentY->setValue(renderShadowSplitExponent.mV[VY]);
|
|
mSliderRenderShadowSplitExponentY->setValue(renderShadowSplitExponent.mV[VY]);
|
|
|
|
LLVector3 renderRenderShadowGaussian = gSavedSettings.getVector3("RenderShadowGaussian");
|
|
mSpinnerRenderShadowGaussianX->setValue(renderRenderShadowGaussian.mV[VX]);
|
|
mSpinnerRenderShadowGaussianY->setValue(renderRenderShadowGaussian.mV[VY]);
|
|
mSliderRenderShadowGaussianX->setValue(renderRenderShadowGaussian.mV[VX]);
|
|
mSliderRenderShadowGaussianY->setValue(renderRenderShadowGaussian.mV[VY]);
|
|
|
|
LLVector3 renderSSAOEffect = gSavedSettings.getVector3("RenderSSAOEffect");
|
|
mSpinnerRenderSSAOEffectX->setValue(renderSSAOEffect.mV[VX]);
|
|
mSliderRenderSSAOEffectX->setValue(renderSSAOEffect.mV[VX]);
|
|
}
|
|
// </FS:CR>
|
|
}
|
|
|
|
void FloaterQuickPrefs::updateRlvRestrictions(ERlvBehaviour behavior, ERlvParamType type)
|
|
{
|
|
if (behavior == RLV_BHVR_SETENV)
|
|
{
|
|
if (type == RLV_TYPE_ADD)
|
|
{
|
|
enableWindlightButtons(FALSE);
|
|
}
|
|
else
|
|
{
|
|
enableWindlightButtons(TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::enableWindlightButtons(BOOL enable)
|
|
{
|
|
childSetEnabled("WLPresetsCombo", enable);
|
|
childSetEnabled("WLPrevPreset", enable);
|
|
childSetEnabled("WLNextPreset", enable);
|
|
childSetEnabled("WaterPresetsCombo", enable);
|
|
childSetEnabled("WWPrevPreset", enable);
|
|
childSetEnabled("WWNextPreset", enable);
|
|
childSetEnabled("ResetToRegionDefault", enable);
|
|
childSetEnabled("UseRegionWindlight", enable);
|
|
childSetEnabled("DCPresetsCombo", enable);
|
|
childSetEnabled("DCPrevPreset", enable);
|
|
childSetEnabled("DCNextPreset", enable);
|
|
//<FS:TS> FIRE-13448: Quickprefs daycycle slider allows evading @setenv=n
|
|
childSetEnabled("WLSunPos", enable);
|
|
//</FS:TS> FIRE-13448
|
|
|
|
if (getIsPhototools())
|
|
{
|
|
childSetEnabled("Sunrise", enable);
|
|
childSetEnabled("Noon", enable);
|
|
childSetEnabled("Sunset", enable);
|
|
childSetEnabled("Midnight", enable);
|
|
childSetEnabled("Revert to Region Default", enable);
|
|
childSetEnabled("new_sky_preset", enable);
|
|
childSetEnabled("edit_sky_preset", enable);
|
|
childSetEnabled("new_water_preset", enable);
|
|
childSetEnabled("edit_water_preset", enable);
|
|
}
|
|
}
|
|
|
|
// <FS:Zi> Dynamic quick prefs
|
|
std::string FloaterQuickPrefs::getSettingsPath(BOOL save_mode)
|
|
{
|
|
// get the settings file name
|
|
std::string settings_file=LLAppViewer::instance()->getSettingsFilename("Default","QuickPreferences");
|
|
// expand to user defined path
|
|
std::string settings_path=gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,settings_file);
|
|
|
|
// if not in save mode, and the file was not found, use the default path
|
|
if(!save_mode && !LLFile::isfile(settings_path))
|
|
{
|
|
settings_path=gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,settings_file);
|
|
}
|
|
return settings_path;
|
|
}
|
|
|
|
void FloaterQuickPrefs::updateControl(const std::string& controlName,ControlEntry& entry)
|
|
{
|
|
// rename the panel to contain the control's name, for identification later
|
|
entry.panel->setName(controlName);
|
|
|
|
// build a list of all possible control widget types
|
|
std::map<ControlType,std::string> typeMap;
|
|
std::map<ControlType,std::string>::iterator it;
|
|
|
|
typeMap[ControlTypeCheckbox]="option_checkbox_control";
|
|
typeMap[ControlTypeText]="option_text_control";
|
|
typeMap[ControlTypeSpinner]="option_spinner_control";
|
|
typeMap[ControlTypeSlider]="option_slider_control";
|
|
typeMap[ControlTypeRadio]="option_radio_control";
|
|
typeMap[ControlTypeColor3]="option_color3_control";
|
|
typeMap[ControlTypeColor4]="option_color4_control";
|
|
|
|
// hide all widget types except for the one the user wants
|
|
LLUICtrl* widget;
|
|
for(it=typeMap.begin();it!=typeMap.end();++it)
|
|
{
|
|
if(entry.type!=it->first)
|
|
{
|
|
widget=entry.panel->getChild<LLUICtrl>(it->second);
|
|
|
|
if (widget)
|
|
{
|
|
// dummy to disable old control
|
|
widget->setControlName("QuickPrefsEditMode");
|
|
widget->setVisible(FALSE);
|
|
widget->setEnabled(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
// get the widget type the user wanted from the panel
|
|
widget=entry.panel->getChild<LLUICtrl>(typeMap[entry.type]);
|
|
|
|
// use 3 decimal places by default
|
|
S32 decimals=3;
|
|
|
|
// save pointer to the widget in our internal list
|
|
entry.widget=widget;
|
|
|
|
// add the settings control to the widget and enable/show it
|
|
widget->setControlName(controlName);
|
|
widget->setVisible(TRUE);
|
|
widget->setEnabled(TRUE);
|
|
|
|
// if no increment is given, try to guess a good number
|
|
if(entry.increment==0.0f)
|
|
{
|
|
// finer grained for sliders
|
|
if(entry.type==ControlTypeSlider)
|
|
{
|
|
entry.increment=(entry.max_value-entry.min_value)/100.0f;
|
|
}
|
|
// a little less for spinners
|
|
else if(entry.type==ControlTypeSpinner)
|
|
{
|
|
entry.increment=(entry.max_value-entry.min_value)/20.0f;
|
|
}
|
|
}
|
|
|
|
// if it's an integer entry, round the numbers
|
|
if(entry.integer)
|
|
{
|
|
entry.min_value=llround(entry.min_value);
|
|
entry.max_value=llround(entry.max_value);
|
|
|
|
// recalculate increment
|
|
entry.increment=llround(entry.increment);
|
|
if(entry.increment==0)
|
|
{
|
|
entry.increment=1;
|
|
}
|
|
|
|
// no decimal places for integers
|
|
decimals=0;
|
|
}
|
|
|
|
// set up values for special case control widget types
|
|
LLUICtrl* alpha_widget=entry.panel->getChild<LLUICtrl>("option_color_alpha_control");
|
|
alpha_widget->setVisible(FALSE);
|
|
|
|
// sadly, using LLF32UICtrl does not work properly, so we have to use a branch
|
|
// for each floating point type
|
|
if(entry.type==ControlTypeSpinner)
|
|
{
|
|
LLSpinCtrl* spinner=(LLSpinCtrl*) widget;
|
|
spinner->setPrecision(decimals);
|
|
spinner->setMinValue(entry.min_value);
|
|
spinner->setMaxValue(entry.max_value);
|
|
spinner->setIncrement(entry.increment);
|
|
}
|
|
else if(entry.type==ControlTypeSlider)
|
|
{
|
|
LLSliderCtrl* slider=(LLSliderCtrl*) widget;
|
|
slider->setPrecision(decimals);
|
|
slider->setMinValue(entry.min_value);
|
|
slider->setMaxValue(entry.max_value);
|
|
slider->setIncrement(entry.increment);
|
|
}
|
|
else if(entry.type==ControlTypeColor4)
|
|
{
|
|
LLColorSwatchCtrl* color_widget=(LLColorSwatchCtrl*) widget;
|
|
alpha_widget->setVisible(TRUE);
|
|
alpha_widget->setValue(color_widget->get().mV[VALPHA]);
|
|
}
|
|
|
|
// reuse a previously created text label if possible
|
|
LLTextBox* label_textbox=entry.label_textbox;
|
|
// if the text label is not known yet, this is a brand new control panel
|
|
if(!label_textbox)
|
|
{
|
|
// otherwise, get the pointer to the new label
|
|
label_textbox=entry.panel->getChild<LLTextBox>("option_label");
|
|
|
|
// add double click and single click callbacks on the text label
|
|
label_textbox->setDoubleClickCallback(boost::bind(&FloaterQuickPrefs::onDoubleClickLabel,this,_1,entry.panel));
|
|
label_textbox->setMouseUpCallback(boost::bind(&FloaterQuickPrefs::onClickLabel,this,_1,entry.panel));
|
|
|
|
// since this is a new control, wire up the remove button signal, too
|
|
LLButton* remove_button=entry.panel->getChild<LLButton>("remove_button");
|
|
remove_button->setCommitCallback(boost::bind(&FloaterQuickPrefs::onRemoveClicked,this,_1,entry.panel));
|
|
|
|
// and the commit signal for the alpha value in a color4 control
|
|
alpha_widget->setCommitCallback(boost::bind(&FloaterQuickPrefs::onAlphaChanged,this,_1,widget));
|
|
|
|
// save the text label pointer in the internal list
|
|
entry.label_textbox=label_textbox;
|
|
}
|
|
// set the value(visible text) for the text label
|
|
label_textbox->setValue(entry.label+":");
|
|
|
|
// get the named control variable from global or per account settings
|
|
LLControlVariable* var=gSavedSettings.getControl(controlName);
|
|
if(!var)
|
|
{
|
|
var=gSavedPerAccountSettings.getControl(controlName);
|
|
}
|
|
|
|
// if we found the control, set up the chosen widget to use it
|
|
if(var)
|
|
{
|
|
widget->setValue(var->getValue());
|
|
widget->setToolTip(var->getComment());
|
|
label_textbox->setToolTip(var->getComment());
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS() << "Could not find control variable " << controlName << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
LLUICtrl* FloaterQuickPrefs::addControl(const std::string& controlName,const std::string& controlLabel,LLView* slot,ControlType type,BOOL integer,F32 min_value,F32 max_value,F32 increment)
|
|
{
|
|
// create a new controls panel
|
|
LLLayoutPanel* panel=LLUICtrlFactory::createFromFile<LLLayoutPanel>("panel_quickprefs_item.xml",NULL,LLLayoutStack::child_registry_t::instance());
|
|
if(!panel)
|
|
{
|
|
LL_WARNS() << "could not add panel" << LL_ENDL;
|
|
return NULL;
|
|
}
|
|
|
|
// sanity checks
|
|
if(max_value<min_value) max_value=min_value;
|
|
// 0.0 will make updateControl calculate the increment itself
|
|
if(increment<0.0f) increment=0.0f;
|
|
|
|
// create a new internal entry for this control
|
|
ControlEntry newControl;
|
|
newControl.panel=panel->getChild<LLPanel>("option_ordering_panel");
|
|
newControl.widget=NULL;
|
|
newControl.label_textbox=NULL;
|
|
newControl.label=controlLabel;
|
|
newControl.type=type;
|
|
newControl.integer=integer;
|
|
newControl.min_value=min_value;
|
|
newControl.max_value=max_value;
|
|
newControl.increment=increment;
|
|
|
|
// update the new control
|
|
updateControl(controlName,newControl);
|
|
|
|
// add the control to the internal list
|
|
mControlsList[controlName]=newControl;
|
|
|
|
// if we have a slot already, reparent our new ordering panel and delete the old layout_panel
|
|
if(slot)
|
|
{
|
|
// add the ordering panel to the slot
|
|
slot->addChild(newControl.panel);
|
|
// make sure the panel moves to the top left corner
|
|
newControl.panel->setOrigin(0,0);
|
|
// resize it to make it fill the slot
|
|
newControl.panel->reshape(slot->getRect().getWidth(),slot->getRect().getHeight());
|
|
// remove the old layout panel from memory
|
|
delete panel;
|
|
}
|
|
// otherwise create a new slot
|
|
else
|
|
{
|
|
// add a new layout_panel to the stack
|
|
mOptionsStack->addPanel(panel,LLLayoutStack::NO_ANIMATE);
|
|
// add the panel to the list of ordering slots
|
|
mOrderingSlots.push_back(panel);
|
|
// make the floater fit the newly added control panel
|
|
reshape(getRect().getWidth(),getRect().getHeight()+panel->getRect().getHeight());
|
|
// show the panel
|
|
panel->setVisible(TRUE);
|
|
}
|
|
|
|
// hide the border
|
|
newControl.panel->setBorderVisible(FALSE);
|
|
|
|
return newControl.widget;
|
|
}
|
|
|
|
void FloaterQuickPrefs::removeControl(const std::string& controlName,BOOL remove_slot)
|
|
{
|
|
// find the control panel to remove
|
|
const control_list_t::iterator it=mControlsList.find(controlName);
|
|
if(it==mControlsList.end())
|
|
{
|
|
LL_WARNS() << "Couldn't find control entry " << controlName << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
// get a pointer to the panel to remove
|
|
LLPanel* panel=it->second.panel;
|
|
// remember the panel's height because it will be deleted by removeChild() later
|
|
S32 height=panel->getRect().getHeight();
|
|
|
|
// remove the panel from the internal list
|
|
mControlsList.erase(it);
|
|
|
|
// get a pointer to the layout slot used
|
|
LLLayoutPanel* slot=(LLLayoutPanel*) panel->getParent();
|
|
// remove the panel from the slot
|
|
slot->removeChild(panel);
|
|
// clear the panel from memory
|
|
delete panel;
|
|
|
|
// remove the layout_panel if desired
|
|
if(remove_slot)
|
|
{
|
|
// remove the slot from our list
|
|
mOrderingSlots.remove(slot);
|
|
// and delete it from the user interface stack
|
|
mOptionsStack->removeChild(slot);
|
|
|
|
// make the floater shrink to its new size
|
|
reshape(getRect().getWidth(),getRect().getHeight()-height);
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::selectControl(std::string controlName)
|
|
{
|
|
// remove previously selected marker, if any
|
|
if(!mSelectedControl.empty() && hasControl( mSelectedControl ) )
|
|
{
|
|
mControlsList[mSelectedControl].panel->setBorderVisible(FALSE);
|
|
}
|
|
|
|
// save the currently selected name in a volatile settings control to
|
|
// enable/disable the editor widgets
|
|
mSelectedControl=controlName;
|
|
gSavedSettings.setString("QuickPrefsSelectedControl",controlName);
|
|
|
|
if( mSelectedControl.size() && !hasControl( mSelectedControl ) )
|
|
{
|
|
mSelectedControl = "";
|
|
return;
|
|
}
|
|
|
|
// if we are not in edit mode, we can stop here
|
|
if(!gSavedSettings.getBOOL("QuickPrefsEditMode"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// select the topmost entry in the name dropdown, in case we don't find the name
|
|
mControlNameCombo->selectNthItem(0);
|
|
|
|
// assume we don't need the min/max/increment/integer widgets by default
|
|
BOOL enable_floating_point=FALSE;
|
|
|
|
// if actually a selection is present, set up the editor widgets
|
|
if(!mSelectedControl.empty())
|
|
{
|
|
// draw the new selection border
|
|
mControlsList[mSelectedControl].panel->setBorderVisible(TRUE);
|
|
|
|
// set up editor values
|
|
mControlLabelEdit->setValue(LLSD(mControlsList[mSelectedControl].label));
|
|
mControlNameCombo->setValue(LLSD(mSelectedControl));
|
|
mControlTypeCombo->setValue(mControlsList[mSelectedControl].type);
|
|
mControlIntegerCheckbox->setValue(LLSD(mControlsList[mSelectedControl].integer));
|
|
mControlMinSpinner->setValue(LLSD(mControlsList[mSelectedControl].min_value));
|
|
mControlMaxSpinner->setValue(LLSD(mControlsList[mSelectedControl].max_value));
|
|
mControlIncrementSpinner->setValue(LLSD(mControlsList[mSelectedControl].increment));
|
|
|
|
// special handling to enable min/max/integer/increment widgets
|
|
switch(mControlsList[mSelectedControl].type)
|
|
{
|
|
// enable floating point widgets for these types
|
|
case ControlTypeSpinner: // fall through
|
|
case ControlTypeSlider: // fall through
|
|
{
|
|
enable_floating_point=TRUE;
|
|
|
|
// assume we have floating point widgets
|
|
mControlIncrementSpinner->setIncrement(0.1f);
|
|
// use 3 decimal places by default
|
|
S32 decimals=3;
|
|
// unless we have an integer control
|
|
if(mControlsList[mSelectedControl].integer)
|
|
{
|
|
decimals=0;
|
|
mControlIncrementSpinner->setIncrement(1.0);
|
|
}
|
|
// set up floating point widgets
|
|
mControlMinSpinner->setPrecision(decimals);
|
|
mControlMaxSpinner->setPrecision(decimals);
|
|
mControlIncrementSpinner->setPrecision(decimals);
|
|
break;
|
|
}
|
|
// the rest will not need them
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
// enable/disable floating point widgets
|
|
mControlMinSpinner->setEnabled(enable_floating_point);
|
|
mControlMaxSpinner->setEnabled(enable_floating_point);
|
|
mControlIntegerCheckbox->setEnabled(enable_floating_point);
|
|
mControlIncrementSpinner->setEnabled(enable_floating_point);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickLabel(LLUICtrl* ctrl,void* userdata)
|
|
{
|
|
// don't do anything when we are not in edit mode
|
|
if(!gSavedSettings.getBOOL("QuickPrefsEditMode"))
|
|
{
|
|
return;
|
|
}
|
|
// get the associated panel from the submitted userdata
|
|
LLUICtrl* panel=(LLUICtrl*) userdata;
|
|
// select the clicked control, identified by its name
|
|
selectControl(panel->getName());
|
|
}
|
|
|
|
void FloaterQuickPrefs::onDoubleClickLabel(LLUICtrl* ctrl,void* userdata)
|
|
{
|
|
// toggle edit mode
|
|
BOOL edit_mode=!gSavedSettings.getBOOL("QuickPrefsEditMode");
|
|
gSavedSettings.setBOOL("QuickPrefsEditMode",edit_mode);
|
|
|
|
// select the double clicked control if we toggled edit on
|
|
if(edit_mode)
|
|
{
|
|
// get the associated widget from the submitted userdata
|
|
LLUICtrl* panel=(LLUICtrl*) userdata;
|
|
selectControl(panel->getName());
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::onEditModeChanged()
|
|
{
|
|
// if edit mode was enabled, stop here
|
|
if(gSavedSettings.getBOOL("QuickPrefsEditMode"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// deselect the current control
|
|
selectControl("");
|
|
|
|
QuickPrefsXML xml;
|
|
std::string settings_path=getSettingsPath(TRUE);
|
|
|
|
// loop through the list of controls, in the displayed order
|
|
std::list<std::string>::iterator it;
|
|
for(it=mControlsOrder.begin();it!=mControlsOrder.end();++it)
|
|
{
|
|
const ControlEntry& entry=mControlsList[*it];
|
|
QuickPrefsXMLEntry xml_entry;
|
|
|
|
// add control values to the XML entry
|
|
xml_entry.control_name=*it;
|
|
xml_entry.label=entry.label;
|
|
xml_entry.control_type=(U32) entry.type;
|
|
xml_entry.integer=entry.integer;
|
|
xml_entry.min_value=entry.min_value;
|
|
xml_entry.max_value=entry.max_value;
|
|
xml_entry.increment=entry.increment;
|
|
|
|
// add the XML entry to the overall XML container
|
|
xml.entries.add(xml_entry);
|
|
}
|
|
|
|
// Serialize the parameter tree
|
|
LLXMLNodePtr output_node=new LLXMLNode("quickprefs",false);
|
|
LLXUIParser parser;
|
|
parser.writeXUI(output_node,xml);
|
|
|
|
// Write the resulting XML to file
|
|
if(!output_node->isNull())
|
|
{
|
|
LLFILE *fp=LLFile::fopen(settings_path,"w");
|
|
if(fp!=NULL)
|
|
{
|
|
LLXMLNode::writeHeaderToFile(fp);
|
|
output_node->writeToFile(fp);
|
|
fclose(fp);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::onValuesChanged()
|
|
{
|
|
// safety, do nothing if we are not in edit mode
|
|
if(!gSavedSettings.getBOOL("QuickPrefsEditMode"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// don't crash when we try to update values without having a control selected
|
|
if(mSelectedControl=="")
|
|
{
|
|
return;
|
|
}
|
|
|
|
// remember the current and possibly new control names
|
|
std::string old_control_name=mSelectedControl;
|
|
std::string new_control_name=mControlNameCombo->getValue();
|
|
|
|
// if we changed the control's variable, rebuild the user interface
|
|
if(!new_control_name.empty() && old_control_name!=new_control_name)
|
|
{
|
|
// remember the old control parameters so we can restore them later
|
|
ControlEntry old_parameters=mControlsList[mSelectedControl];
|
|
// disable selection so the border doesn't cause a crash
|
|
selectControl("");
|
|
// rename the old ordering entry
|
|
std::list<std::string>::iterator it;
|
|
for(it=mControlsOrder.begin();it!=mControlsOrder.end();++it)
|
|
{
|
|
if(*it==old_control_name)
|
|
{
|
|
*it=new_control_name;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// remember the old slot
|
|
LLView* slot=old_parameters.panel->getParent();
|
|
// remove the old control name from the internal list but keep the slot available
|
|
removeControl(old_control_name,FALSE);
|
|
// add new control with the old slot
|
|
addControl(new_control_name,new_control_name,slot);
|
|
// grab the new values and make the selection border go to the right panel
|
|
selectControl(new_control_name);
|
|
// restore the old UI settings
|
|
mControlsList[mSelectedControl].label=old_parameters.label;
|
|
// find the control variable in global or per account settings
|
|
LLControlVariable* var=gSavedSettings.getControl(mSelectedControl);
|
|
if(!var)
|
|
{
|
|
var=gSavedPerAccountSettings.getControl(mSelectedControl);
|
|
}
|
|
|
|
if(var && hasControl(mSelectedControl) )
|
|
{
|
|
// choose sane defaults for floating point controls, so the control value won't be destroyed
|
|
// start with these
|
|
F32 min_value=0.0;
|
|
F32 max_value=1.0;
|
|
F32 value=var->getValue().asReal();
|
|
|
|
// if the value was negative and smaller than the current minimum
|
|
if(value<0.0f)
|
|
{
|
|
// make the minimum even smaller
|
|
min_value=value*2.0f;
|
|
}
|
|
// if the value is above zero, set max to double of the current value
|
|
else if(value>0.0f)
|
|
{
|
|
max_value=value*2.0f;
|
|
}
|
|
|
|
// do a best guess on variable types and control widgets
|
|
ControlType type;
|
|
switch(var->type())
|
|
{
|
|
// Boolean gets the full set
|
|
case TYPE_BOOLEAN:
|
|
{
|
|
// increment will be calculated below
|
|
min_value=0.0;
|
|
max_value=1.0;
|
|
type=ControlTypeRadio;
|
|
break;
|
|
}
|
|
// LLColor3/4 are just colors
|
|
case TYPE_COL3:
|
|
{
|
|
type=ControlTypeColor3;
|
|
break;
|
|
}
|
|
case TYPE_COL4:
|
|
{
|
|
type=ControlTypeColor4;
|
|
break;
|
|
}
|
|
// U32 can never be negative
|
|
case TYPE_U32:
|
|
{
|
|
min_value=0.0;
|
|
}
|
|
// Fallthrough, S32 and U32 are integer values
|
|
case TYPE_S32:
|
|
// Fallthrough, S32, U32 and F32 should use sliders
|
|
case TYPE_F32:
|
|
{
|
|
type=ControlTypeSlider;
|
|
break;
|
|
}
|
|
// Everything else gets a text widget for now
|
|
default:
|
|
{
|
|
type=ControlTypeText;
|
|
}
|
|
}
|
|
|
|
// choose a sane increment
|
|
F32 increment=0.1f;
|
|
if( mControlsList[mSelectedControl].type==ControlTypeSlider )
|
|
{
|
|
// fine grained control for sliders
|
|
increment=(max_value-min_value)/100.0f;
|
|
}
|
|
else if( mControlsList[mSelectedControl].type==ControlTypeSpinner)
|
|
{
|
|
// not as fine grained for spinners
|
|
increment=(max_value-min_value)/20.0f;
|
|
}
|
|
|
|
// don't let values go too small
|
|
if(increment<0.1)
|
|
{
|
|
increment=0.1f;
|
|
}
|
|
|
|
// save calculated values to the edit widgets
|
|
mControlsList[mSelectedControl].min_value=min_value;
|
|
mControlsList[mSelectedControl].max_value=max_value;
|
|
mControlsList[mSelectedControl].increment=increment;
|
|
mControlsList[mSelectedControl].type=type; // old_parameters.type;
|
|
mControlsList[mSelectedControl].widget->setValue(var->getValue());
|
|
}
|
|
// rebuild controls UI (probably not needed)
|
|
// updateControls();
|
|
// update our new control
|
|
updateControl(mSelectedControl,mControlsList[mSelectedControl]);
|
|
}
|
|
// the control's setting variable is still the same, so just update the values
|
|
else if( hasControl(mSelectedControl) )
|
|
{
|
|
mControlsList[mSelectedControl].label=mControlLabelEdit->getValue().asString();
|
|
mControlsList[mSelectedControl].type=(ControlType) mControlTypeCombo->getValue().asInteger();
|
|
mControlsList[mSelectedControl].integer=mControlIntegerCheckbox->getValue().asBoolean();
|
|
mControlsList[mSelectedControl].min_value=mControlMinSpinner->getValue().asReal();
|
|
mControlsList[mSelectedControl].max_value=mControlMaxSpinner->getValue().asReal();
|
|
mControlsList[mSelectedControl].increment=mControlIncrementSpinner->getValue().asReal();
|
|
// and update the user interface
|
|
updateControl(mSelectedControl,mControlsList[mSelectedControl]);
|
|
}
|
|
// select the control
|
|
selectControl(mSelectedControl);
|
|
|
|
// <FS:ND>
|
|
// setting focus can lead to an endless loop of two floaters fighting for focus. See FIRE-9634
|
|
// so we rather deal with focus loss sometimes (how often?) than a nasty hang
|
|
|
|
// // sometimes we seem to lose focus, so make sure we keep it
|
|
// setFocus(TRUE);
|
|
|
|
// </FS:ND>
|
|
}
|
|
|
|
void FloaterQuickPrefs::onAddNewClicked()
|
|
{
|
|
// count a number to keep control names unique
|
|
static S32 sCount=0;
|
|
std::string new_control_name="NewControl"+LLSD(sCount).asString();
|
|
// add the new control to the internal list and user interface
|
|
addControl(new_control_name,new_control_name);
|
|
// put it at the bottom of the ordering stack
|
|
mControlsOrder.push_back(new_control_name);
|
|
sCount++;
|
|
// select the newly created control
|
|
selectControl(new_control_name);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onRemoveClicked(LLUICtrl* ctrl,void* userdata)
|
|
{
|
|
// get the associated panel from the submitted userdata
|
|
LLUICtrl* panel=(LLUICtrl*) userdata;
|
|
// deselect the current entry
|
|
selectControl("");
|
|
// first remove the control from the ordering list
|
|
mControlsOrder.remove(panel->getName());
|
|
// then remove it from the internal list and from memory
|
|
removeControl(panel->getName());
|
|
// reinstate focus in case we lost it
|
|
setFocus(TRUE);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onAlphaChanged(LLUICtrl* ctrl,void* userdata)
|
|
{
|
|
// get the associated color swatch from the submitted userdata
|
|
LLColorSwatchCtrl* color_swatch=(LLColorSwatchCtrl*) userdata;
|
|
// get the current color
|
|
LLColor4 color=color_swatch->get();
|
|
// replace the alpha value of the color with the value in the alpha spinner
|
|
color.setAlpha(ctrl->getValue().asReal());
|
|
// save the color back into the color swatch
|
|
color_swatch->getControlVariable()->setValue(color.getValue());
|
|
}
|
|
|
|
void FloaterQuickPrefs::swapControls(const std::string& control1, const std::string& control2)
|
|
{
|
|
// get the control entries of both controls
|
|
ControlEntry temp_entry_1=mControlsList[control1];
|
|
ControlEntry temp_entry_2=mControlsList[control2];
|
|
|
|
// find the respective ordering slots
|
|
LLView* temp_slot_1=temp_entry_1.panel->getParent();
|
|
LLView* temp_slot_2=temp_entry_2.panel->getParent();
|
|
|
|
// swap the controls around
|
|
temp_slot_1->addChild(temp_entry_2.panel);
|
|
temp_slot_2->addChild(temp_entry_1.panel);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onMoveUpClicked()
|
|
{
|
|
// find the control in the ordering list
|
|
std::list<std::string>::iterator it;
|
|
for(it=mControlsOrder.begin();it!=mControlsOrder.end();++it)
|
|
{
|
|
if(*it==mSelectedControl)
|
|
{
|
|
// if it's already on top of the list, do nothing
|
|
if(it==mControlsOrder.begin())
|
|
return;
|
|
|
|
// get the iterator of the previous item
|
|
std::list<std::string>::iterator previous=it;
|
|
--previous;
|
|
|
|
// copy the previous item to the one we want to move
|
|
*it=*previous;
|
|
// copy the moving item to previous
|
|
*previous=mSelectedControl;
|
|
// update the user interface
|
|
swapControls(mSelectedControl,*it);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
void FloaterQuickPrefs::onMoveDownClicked()
|
|
{
|
|
// find the control in the ordering list
|
|
std::list<std::string>::iterator it;
|
|
for(it=mControlsOrder.begin();it!=mControlsOrder.end();++it)
|
|
{
|
|
if(*it==mSelectedControl)
|
|
{
|
|
// if it's already at the end of the list, do nothing
|
|
if(*it==mControlsOrder.back())
|
|
return;
|
|
|
|
// get the iterator of the next item
|
|
std::list<std::string>::iterator next=it;
|
|
++next;
|
|
|
|
// copy the next item to the one we want to move
|
|
*it=*next;
|
|
// copy the moving item to next
|
|
*next=mSelectedControl;
|
|
// update the user interface
|
|
swapControls(mSelectedControl,*it);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClose(bool app_quitting)
|
|
{
|
|
// bail out here if this is a reused Phototools floater
|
|
if(getIsPhototools())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// close edit mode and save settings
|
|
gSavedSettings.setBOOL("QuickPrefsEditMode",FALSE);
|
|
}
|
|
// </FS:Zi>
|
|
|
|
// <FS:CR> FIRE-9630 - Vignette UI callbacks
|
|
void FloaterQuickPrefs::onChangeVignetteX()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
vignette.mV[VX] = mSliderVignetteX->getValueF32();
|
|
mSpinnerVignetteX->setValue(vignette.mV[VX]);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeVignetteY()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
vignette.mV[VY] = mSliderVignetteY->getValueF32();
|
|
mSpinnerVignetteY->setValue(vignette.mV[VY]);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeVignetteZ()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
vignette.mV[VZ] = mSliderVignetteZ->getValueF32();
|
|
mSpinnerVignetteZ->setValue(vignette.mV[VZ]);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeVignetteSpinnerX()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
vignette.mV[VX] = mSpinnerVignetteX->getValueF32();
|
|
mSliderVignetteX->setValue(vignette.mV[VX]);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeVignetteSpinnerY()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
vignette.mV[VY] = mSpinnerVignetteY->getValueF32();
|
|
mSliderVignetteY->setValue(vignette.mV[VY]);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeVignetteSpinnerZ()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
vignette.mV[VZ] = mSpinnerVignetteZ->getValueF32();
|
|
mSliderVignetteZ->setValue(vignette.mV[VZ]);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetVignetteX()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
// FIXME: Don't use a hardcoded default value for resetting to default.
|
|
vignette.mV[VX] = 0.0;
|
|
mSliderVignetteX->setValue(0);
|
|
mSpinnerVignetteX->setValue(0);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetVignetteY()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
// FIXME: Don't use a hardcoded default value for resetting to default.
|
|
vignette.mV[VY] = 1.0;
|
|
mSliderVignetteY->setValue(1);
|
|
mSpinnerVignetteY->setValue(1);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetVignetteZ()
|
|
{
|
|
LLVector3 vignette = gSavedSettings.getVector3("FSRenderVignette");
|
|
// FIXME: Don't use a hardcoded default value for resetting to default.
|
|
vignette.mV[VZ] = 1.0;
|
|
mSliderVignetteZ->setValue(1);
|
|
mSpinnerVignetteZ->setValue(1);
|
|
gSavedSettings.setVector3("FSRenderVignette", vignette);
|
|
}
|
|
// </FS:CR> FIRE-9630 - Vignette UI callbacks
|
|
|
|
|
|
void FloaterQuickPrefs::onChangeRenderShadowSplitExponentSlider()
|
|
{
|
|
LLVector3 renderShadowSplitExponent = gSavedSettings.getVector3("RenderShadowSplitExponent");
|
|
renderShadowSplitExponent.mV[VY] = mSliderRenderShadowSplitExponentY->getValueF32();
|
|
mSpinnerRenderShadowSplitExponentY->setValue(renderShadowSplitExponent.mV[VY]);
|
|
gSavedSettings.setVector3("RenderShadowSplitExponent", renderShadowSplitExponent);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeRenderShadowSplitExponentSpinner()
|
|
{
|
|
LLVector3 renderShadowSplitExponent = gSavedSettings.getVector3("RenderShadowSplitExponent");
|
|
renderShadowSplitExponent.mV[VY] = mSpinnerRenderShadowSplitExponentY->getValueF32();
|
|
mSliderRenderShadowSplitExponentY->setValue(renderShadowSplitExponent.mV[VY]);
|
|
gSavedSettings.setVector3("RenderShadowSplitExponent", renderShadowSplitExponent);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetRenderShadowSplitExponentY()
|
|
{
|
|
LLVector3 renderShadowSplitExponentDefault = LLVector3(gSavedSettings.getControl("RenderShadowSplitExponent")->getDefault());
|
|
LLVector3 renderShadowSplitExponent = gSavedSettings.getVector3("RenderShadowSplitExponent");
|
|
renderShadowSplitExponent.mV[VY] = renderShadowSplitExponentDefault.mV[VY];
|
|
mSpinnerRenderShadowSplitExponentY->setValue(renderShadowSplitExponent.mV[VY]);
|
|
mSliderRenderShadowSplitExponentY->setValue(renderShadowSplitExponent.mV[VY]);
|
|
gSavedSettings.setVector3("RenderShadowSplitExponent", renderShadowSplitExponent);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeRenderShadowGaussianSlider()
|
|
{
|
|
LLVector3 renderShadowGaussian = gSavedSettings.getVector3("RenderShadowGaussian");
|
|
renderShadowGaussian.mV[VX] = mSliderRenderShadowGaussianX->getValueF32();
|
|
renderShadowGaussian.mV[VY] = mSliderRenderShadowGaussianY->getValueF32();
|
|
mSpinnerRenderShadowGaussianX->setValue(renderShadowGaussian.mV[VX]);
|
|
mSpinnerRenderShadowGaussianY->setValue(renderShadowGaussian.mV[VY]);
|
|
gSavedSettings.setVector3("RenderShadowGaussian", renderShadowGaussian);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeRenderShadowGaussianSpinner()
|
|
{
|
|
LLVector3 renderShadowGaussian = gSavedSettings.getVector3("RenderShadowGaussian");
|
|
renderShadowGaussian.mV[VX] = mSpinnerRenderShadowGaussianX->getValueF32();
|
|
renderShadowGaussian.mV[VY] = mSpinnerRenderShadowGaussianY->getValueF32();
|
|
mSliderRenderShadowGaussianX->setValue(renderShadowGaussian.mV[VX]);
|
|
mSliderRenderShadowGaussianY->setValue(renderShadowGaussian.mV[VY]);
|
|
gSavedSettings.setVector3("RenderShadowGaussian", renderShadowGaussian);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetRenderShadowGaussianX()
|
|
{
|
|
LLVector3 renderShadowGaussianDefault = LLVector3(gSavedSettings.getControl("RenderShadowGaussian")->getDefault());
|
|
LLVector3 renderShadowGaussian = gSavedSettings.getVector3("RenderShadowGaussian");
|
|
renderShadowGaussian.mV[VX] = renderShadowGaussianDefault.mV[VX];
|
|
mSpinnerRenderShadowGaussianX->setValue(renderShadowGaussian.mV[VX]);
|
|
mSliderRenderShadowGaussianX->setValue(renderShadowGaussian.mV[VX]);
|
|
gSavedSettings.setVector3("RenderShadowGaussian", renderShadowGaussian);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetRenderShadowGaussianY()
|
|
{
|
|
LLVector3 renderShadowGaussianDefault = LLVector3(gSavedSettings.getControl("RenderShadowGaussian")->getDefault());
|
|
LLVector3 renderShadowGaussian = gSavedSettings.getVector3("RenderShadowGaussian");
|
|
renderShadowGaussian.mV[VY] = renderShadowGaussianDefault.mV[VY];
|
|
mSpinnerRenderShadowGaussianY->setValue(renderShadowGaussian.mV[VY]);
|
|
mSliderRenderShadowGaussianY->setValue(renderShadowGaussian.mV[VY]);
|
|
gSavedSettings.setVector3("RenderShadowGaussian", renderShadowGaussian);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeRenderSSAOEffectSlider()
|
|
{
|
|
LLVector3 renderSSAOEffect = gSavedSettings.getVector3("RenderSSAOEffect");
|
|
renderSSAOEffect.mV[VX] = mSliderRenderSSAOEffectX->getValueF32();
|
|
mSpinnerRenderSSAOEffectX->setValue(renderSSAOEffect.mV[VX]);
|
|
gSavedSettings.setVector3("RenderSSAOEffect", renderSSAOEffect);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onChangeRenderSSAOEffectSpinner()
|
|
{
|
|
LLVector3 renderSSAOEffect = gSavedSettings.getVector3("RenderSSAOEffect");
|
|
renderSSAOEffect.mV[VX] = mSpinnerRenderSSAOEffectX->getValueF32();
|
|
mSliderRenderSSAOEffectX->setValue(renderSSAOEffect.mV[VX]);
|
|
gSavedSettings.setVector3("RenderSSAOEffect", renderSSAOEffect);
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickResetRenderSSAOEffectX()
|
|
{
|
|
LLVector3 renderSSAOEffectDefault = LLVector3(gSavedSettings.getControl("RenderSSAOEffect")->getDefault());
|
|
LLVector3 renderSSAOEffect = gSavedSettings.getVector3("RenderSSAOEffect");
|
|
renderSSAOEffect.mV[VX] = renderSSAOEffectDefault.mV[VX];
|
|
mSpinnerRenderSSAOEffectX->setValue(renderSSAOEffect.mV[VX]);
|
|
mSliderRenderSSAOEffectX->setValue(renderSSAOEffect.mV[VX]);
|
|
gSavedSettings.setVector3("RenderSSAOEffect", renderSSAOEffect);
|
|
}
|
|
|
|
// <FS:CR> FIRE-9407 - Restore Quickprefs Defaults
|
|
void FloaterQuickPrefs::callbackRestoreDefaults(const LLSD& notification, const LLSD& response)
|
|
{
|
|
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
|
|
if ( option == 0 ) // YES
|
|
{
|
|
selectControl("");
|
|
BOOST_FOREACH(const std::string& control, mControlsOrder)
|
|
{
|
|
removeControl(control);
|
|
}
|
|
mControlsOrder.clear();
|
|
std::string settings_file = LLAppViewer::instance()->getSettingsFilename("Default", "QuickPreferences");
|
|
LLFile::remove(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, settings_file));
|
|
loadSavedSettingsFromFile(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, settings_file));
|
|
gSavedSettings.setBOOL("QuickPrefsEditMode", FALSE);
|
|
}
|
|
else
|
|
{
|
|
LL_INFOS() << "User cancelled the reset." << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
void FloaterQuickPrefs::onClickRestoreDefaults()
|
|
{
|
|
LLNotificationsUtil::add("ConfirmRestoreQuickPrefsDefaults", LLSD(), LLSD(), boost::bind(&FloaterQuickPrefs::callbackRestoreDefaults, this, _1, _2));
|
|
}
|
|
// </FS:CR>
|