LLUICtrl::LLUICtrl(const std::string& name, const LLRect rect, BOOL mouse_opaque,
commit_callback_t commit_callback,
U32 reshape)
: // can't make this automatically follow top and left, breaks lots
// of buttons in the UI. JC 7/20/2002
LLView( name, rect, mouse_opaque, reshape ),
mIsChrome(FALSE),
mRequestsFront(false),
mTabStop( TRUE ),
mTentative( FALSE ),
mViewModel(LLViewModelPtr(new LLViewModel)),
mEnabledControlVariable(nullptr),
mDisabledControlVariable(nullptr),
mMakeVisibleControlVariable(nullptr),
mMakeInvisibleControlVariable(nullptr),
mCommitSignal(nullptr),
mValidateSignal(nullptr),
mMouseEnterSignal(nullptr),
mMouseLeaveSignal(nullptr),
mMouseDownSignal(nullptr),
mMouseUpSignal(nullptr),
mRightMouseDownSignal(nullptr),
mRightMouseUpSignal(nullptr),
mDoubleClickSignal(nullptr),
mCommitOnReturn(FALSE),
mTransparencyType(TT_DEFAULT)
{
if(commit_callback)
setCommitCallback(commit_callback);
}
// initialize parameters
void PieSlice::initFromParams(const Params& p)
{
// add a callback if on_click is provided
if(p.on_click.isProvided())
{
setCommitCallback(initCommitCallback(p.on_click));
}
// add a callback if on_visible is provided
if (p.on_visible.isProvided())
{
mVisibleSignal.connect(initEnableCallback(p.on_visible));
}
// add a callback if on_enable is provided
if (p.on_enable.isProvided())
{
setEnableCallback(initEnableCallback(p.on_enable));
// Set the enabled control variable (for backwards compatability)
if (p.on_enable.control_name.isProvided() && !p.on_enable.control_name().empty())
{
LLControlVariable* control = findControl(p.on_enable.control_name());
if (control)
{
setEnabledControlVariable(control);
}
}
}
LLUICtrl::initFromParams(p);
}
LLPanelCameraItem::LLPanelCameraItem(const LLPanelCameraItem::Params& p)
: LLPanel(p)
{
LLIconCtrl::Params icon_params = p.picture;
mPicture = LLUICtrlFactory::create<LLIconCtrl>(icon_params);
addChild(mPicture);
icon_params = p.icon_over;
mIconOver = LLUICtrlFactory::create<LLIconCtrl>(icon_params);
addChild(mIconOver);
icon_params = p.icon_selected;
mIconSelected = LLUICtrlFactory::create<LLIconCtrl>(icon_params);
addChild(mIconSelected);
icon_params = p.selected_picture;
mPictureSelected = LLUICtrlFactory::create<LLIconCtrl>(icon_params);
addChild(mPictureSelected);
LLTextBox::Params text_params = p.text;
mText = LLUICtrlFactory::create<LLTextBox>(text_params);
addChild(mText);
if (p.mousedown_callback.isProvided())
{
setCommitCallback(initCommitCallback(p.mousedown_callback));
}
}
BOOL LLPanelMarketplaceListings::postBuild()
{
childSetAction("add_btn", boost::bind(&LLPanelMarketplaceListings::onAddButtonClicked, this));
childSetAction("audit_btn", boost::bind(&LLPanelMarketplaceListings::onAuditButtonClicked, this));
mMenu = LLUICtrlFactory::instance().buildMenu("menu_marketplace_view.xml", LLMenuGL::sMenuContainer);
auto sort = getChild<LLUICtrl>("sort_btn");
sort->setCommitCallback(boost::bind(showMenu, _1, mMenu));
mFilterEditor = getChild<LLFilterEditor>("filter_editor");
mFilterEditor->setCommitCallback(boost::bind(&LLPanelMarketplaceListings::onFilterEdit, this, _2));
mAuditBtn = getChild<LLButton>("audit_btn");
mAuditBtn->setEnabled(FALSE);
return LLPanel::postBuild();
}
LLGestureComboList::LLGestureComboList(const LLGestureComboList::Params& p)
: LLUICtrl(p),
mLabel(p.label),
mViewAllItemIndex(-1),
mGetMoreItemIndex(-1),
mShowViewAll(p.view_all),
mShowGetMore(p.get_more)
{
LLBottomtrayButton::Params button_params = p.combo_button;
button_params.follows.flags(FOLLOWS_LEFT|FOLLOWS_BOTTOM|FOLLOWS_RIGHT);
mButton = LLUICtrlFactory::create<LLBottomtrayButton>(button_params);
mButton->reshape(getRect().getWidth(),getRect().getHeight());
mButton->setCommitCallback(boost::bind(&LLGestureComboList::onButtonCommit, this));
addChild(mButton);
LLGestureScrollListCtrl::Params params(p.combo_list);
params.name("GestureComboList");
params.commit_callback.function(boost::bind(&LLGestureComboList::onItemSelected, this, _2));
params.visible(false);
params.commit_on_keyboard_movement(false);
mList = LLUICtrlFactory::create<LLGestureScrollListCtrl>(params);
addChild(mList);
//****************************Gesture Part********************************/
setCommitCallback(boost::bind(&LLGestureComboList::onCommitGesture, this));
// now register us as observer since we have a place to put the results
LLGestureMgr::instance().addObserver(this);
// refresh list from current active gestures
refreshGestures();
setFocusLostCallback(boost::bind(&LLGestureComboList::hideList, this));
}
LLSearchComboBox::LLSearchComboBox(const Params&p)
: LLComboBox(p)
{
S32 btn_top = p.search_button.top_pad + p.search_button.rect.height;
S32 btn_right = p.search_button.rect.width + p.search_button.left_pad;
LLRect search_btn_rect(p.search_button.left_pad, btn_top, btn_right, p.search_button.top_pad);
LLButton::Params button_params(p.search_button);
button_params.name(std::string("search_btn"));
button_params.rect(search_btn_rect) ;
button_params.follows.flags(FOLLOWS_LEFT|FOLLOWS_TOP);
button_params.tab_stop(false);
button_params.click_callback.function(boost::bind(&LLSearchComboBox::onSelectionCommit, this));
mSearchButton = LLUICtrlFactory::create<LLButton>(button_params);
mTextEntry->addChild(mSearchButton);
mTextEntry->setPassDelete(TRUE);
setButtonVisible(p.dropdown_button_visible);
mTextEntry->setCommitCallback(boost::bind(&LLComboBox::onTextCommit, this, _2));
mTextEntry->setKeystrokeCallback(boost::bind(&LLComboBox::onTextEntry, this, _1), NULL);
setCommitCallback(boost::bind(&LLSearchComboBox::onSelectionCommit, this));
setPrearrangeCallback(boost::bind(&LLSearchComboBox::onSearchPrearrange, this, _2));
mSearchButton->setCommitCallback(boost::bind(&LLSearchComboBox::onTextCommit, this, _2));
}
// *TODO: Deprecate; for backwards compatability only:
boost::signals2::connection LLUICtrl::setCommitCallback( boost::function<void (LLUICtrl*,void*)> cb, void* data)
{
return setCommitCallback( boost::bind(cb, _1, data));
}
void LLUICtrl::initFromParams(const Params& p)
{
LLView::initFromParams(p);
setIsChrome(p.chrome);
setControlName(p.control_name);
if(p.enabled_controls.isProvided())
{
if (p.enabled_controls.enabled.isChosen())
{
LLControlVariable* control = findControl(p.enabled_controls.enabled);
if (control)
setEnabledControlVariable(control);
}
else if(p.enabled_controls.disabled.isChosen())
{
LLControlVariable* control = findControl(p.enabled_controls.disabled);
if (control)
setDisabledControlVariable(control);
}
}
if(p.controls_visibility.isProvided())
{
if (p.controls_visibility.visible.isChosen())
{
LLControlVariable* control = findControl(p.controls_visibility.visible);
if (control)
setMakeVisibleControlVariable(control);
}
else if (p.controls_visibility.invisible.isChosen())
{
LLControlVariable* control = findControl(p.controls_visibility.invisible);
if (control)
setMakeInvisibleControlVariable(control);
}
}
setTabStop(p.tab_stop);
if (p.initial_value.isProvided()
&& !p.control_name.isProvided())
{
setValue(p.initial_value);
}
if (p.commit_callback.isProvided())
{
setCommitCallback(initCommitCallback(p.commit_callback));
}
if (p.validate_callback.isProvided())
{
setValidateCallback(initEnableCallback(p.validate_callback));
}
if (p.init_callback.isProvided())
{
if (p.init_callback.function.isProvided())
{
p.init_callback.function()(this, p.init_callback.parameter);
}
else
{
commit_callback_t* initfunc = (CommitCallbackRegistry::getValue(p.init_callback.function_name));
if (initfunc)
{
(*initfunc)(this, p.init_callback.parameter);
}
}
}
if(p.mouseenter_callback.isProvided())
{
setMouseEnterCallback(initCommitCallback(p.mouseenter_callback));
}
if(p.mouseleave_callback.isProvided())
{
setMouseLeaveCallback(initCommitCallback(p.mouseleave_callback));
}
}
LLButton::LLButton(const LLButton::Params& p)
: LLUICtrl(p),
mMouseDownFrame(0),
mMouseHeldDownCount(0),
mBorderEnabled( FALSE ),
mFlashing( FALSE ),
mCurGlowStrength(0.f),
mNeedsHighlight(FALSE),
mMouseOver(false),
mUnselectedLabel(p.label()),
mSelectedLabel(p.label_selected()),
mGLFont(p.font),
mHeldDownDelay(p.held_down_delay.seconds), // seconds until held-down callback is called
mHeldDownFrameDelay(p.held_down_delay.frames),
mImageUnselected(p.image_unselected),
mImageSelected(p.image_selected),
mImageDisabled(p.image_disabled),
mImageDisabledSelected(p.image_disabled_selected),
mImageFlash(p.image_flash),
mImagePressed(p.image_pressed),
mImagePressedSelected(p.image_pressed_selected),
mImageHoverSelected(p.image_hover_selected),
mImageHoverUnselected(p.image_hover_unselected),
mUnselectedLabelColor(p.label_color()),
mSelectedLabelColor(p.label_color_selected()),
mDisabledLabelColor(p.label_color_disabled()),
mDisabledSelectedLabelColor(p.label_color_disabled_selected()),
mHighlightColor(p.highlight_color()),
mImageColor(p.image_color()),
mFlashBgColor(p.flash_color()),
mDisabledImageColor(p.image_color_disabled()),
mImageOverlay(p.image_overlay()),
mImageOverlayColor(p.image_overlay_color()),
mImageOverlayAlignment(LLFontGL::hAlignFromName(p.image_overlay_alignment)),
mImageOverlayTopPad(p.image_top_pad),
mImageOverlayBottomPad(p.image_bottom_pad),
mImgOverlayLabelSpace(p.imgoverlay_label_space),
mIsToggle(p.is_toggle),
mScaleImage(p.scale_image),
mDropShadowedText(p.label_shadow),
mAutoResize(p.auto_resize),
mUseEllipses( p.use_ellipses ),
mHAlign(p.font_halign),
mLeftHPad(p.pad_left),
mRightHPad(p.pad_right),
mBottomVPad(p.pad_bottom),
mHoverGlowStrength(p.hover_glow_amount),
mCommitOnReturn(p.commit_on_return),
mFadeWhenDisabled(FALSE),
mForcePressedState(false),
mLastDrawCharsCount(0),
mMouseDownSignal(NULL),
mMouseUpSignal(NULL),
mHeldDownSignal(NULL)
{
static LLUICachedControl<S32> llbutton_orig_h_pad ("UIButtonOrigHPad", 0);
static Params default_params(LLUICtrlFactory::getDefaultParams<LLButton>());
if (!p.label_selected.isProvided())
{
mSelectedLabel = mUnselectedLabel;
}
// Hack to make sure there is space for at least one character
if (getRect().getWidth() - (mRightHPad + mLeftHPad) < mGLFont->getWidth(std::string(" ")))
{
// Use old defaults
mLeftHPad = llbutton_orig_h_pad;
mRightHPad = llbutton_orig_h_pad;
}
mMouseDownTimer.stop();
// if custom unselected button image provided...
if (p.image_unselected != default_params.image_unselected)
{
//...fade it out for disabled image by default...
if (p.image_disabled() == default_params.image_disabled() )
{
mImageDisabled = p.image_unselected;
mFadeWhenDisabled = TRUE;
}
if (p.image_pressed_selected == default_params.image_pressed_selected)
{
mImagePressedSelected = mImageUnselected;
}
}
// if custom selected button image provided...
if (p.image_selected != default_params.image_selected)
{
//...fade it out for disabled image by default...
if (p.image_disabled_selected() == default_params.image_disabled_selected())
{
mImageDisabledSelected = p.image_selected;
mFadeWhenDisabled = TRUE;
}
if (p.image_pressed == default_params.image_pressed)
{
mImagePressed = mImageSelected;
}
}
if (!p.image_pressed.isProvided())
{
mImagePressed = mImageSelected;
}
if (!p.image_pressed_selected.isProvided())
{
mImagePressedSelected = mImageUnselected;
}
if (mImageUnselected.isNull())
{
llwarns << "Button: " << getName() << " with no image!" << llendl;
}
if (p.click_callback.isProvided())
{
setCommitCallback(initCommitCallback(p.click_callback)); // alias -> commit_callback
}
if (p.mouse_down_callback.isProvided())
{
setMouseDownCallback(initCommitCallback(p.mouse_down_callback));
}
if (p.mouse_up_callback.isProvided())
{
setMouseUpCallback(initCommitCallback(p.mouse_up_callback));
}
if (p.mouse_held_callback.isProvided())
{
setHeldDownCallback(initCommitCallback(p.mouse_held_callback));
}
}
LLButton::LLButton(const LLButton::Params& p)
: LLUICtrl(p),
LLBadgeOwner(getHandle()),
mMouseDownFrame(0),
mMouseHeldDownCount(0),
mBorderEnabled( FALSE ),
mFlashing( FALSE ),
mCurGlowStrength(0.f),
mNeedsHighlight(FALSE),
mUnselectedLabel(p.label()),
mSelectedLabel(p.label_selected()),
mGLFont(p.font),
mHeldDownDelay(p.held_down_delay.seconds), // seconds until held-down callback is called
mHeldDownFrameDelay(p.held_down_delay.frames),
mImageUnselected(p.image_unselected),
mImageSelected(p.image_selected),
mImageDisabled(p.image_disabled),
mImageDisabledSelected(p.image_disabled_selected),
mImageFlash(p.image_flash),
mImagePressed(p.image_pressed),
mImagePressedSelected(p.image_pressed_selected),
mImageHoverSelected(p.image_hover_selected),
mImageHoverUnselected(p.image_hover_unselected),
mUnselectedLabelColor(p.label_color()),
mSelectedLabelColor(p.label_color_selected()),
mDisabledLabelColor(p.label_color_disabled()),
mDisabledSelectedLabelColor(p.label_color_disabled_selected()),
mImageColor(p.image_color()),
mFlashBgColor(p.flash_color()),
mDisabledImageColor(p.image_color_disabled()),
mImageOverlay(p.image_overlay()),
mImageOverlayColor(p.image_overlay_color()),
mImageOverlayDisabledColor(p.image_overlay_disabled_color()),
mImageOverlaySelectedColor(p.image_overlay_selected_color()),
mImageOverlayAlignment(LLFontGL::hAlignFromName(p.image_overlay_alignment)),
mImageOverlayTopPad(p.image_top_pad),
mImageOverlayBottomPad(p.image_bottom_pad),
mImgOverlayLabelSpace(p.imgoverlay_label_space),
mIsToggle(p.is_toggle),
mScaleImage(p.scale_image),
mDropShadowedText(p.label_shadow),
mAutoResize(p.auto_resize),
mUseEllipses( p.use_ellipses ),
mHAlign(p.font_halign),
mLeftHPad(p.pad_left),
mRightHPad(p.pad_right),
mBottomVPad(p.pad_bottom),
mHoverGlowStrength(p.hover_glow_amount),
mCommitOnReturn(p.commit_on_return),
mFadeWhenDisabled(FALSE),
mForcePressedState(false),
mDisplayPressedState(p.display_pressed_state),
mLastDrawCharsCount(0),
mMouseDownSignal(NULL),
mMouseUpSignal(NULL),
mHeldDownSignal(NULL),
mUseDrawContextAlpha(p.use_draw_context_alpha),
mHandleRightMouse(p.handle_right_mouse),
// <FS:Zi> Add checkbox control toggle
//mFlashingTimer(NULL)
mFlashingTimer(NULL),
mCheckboxControl(p.checkbox_control),
mCheckboxControlPanel(NULL)
// </FS:Zi>
{
if (p.button_flash_enable)
{
// If optional parameter "p.button_flash_count" is not provided, LLFlashTimer will be
// used instead it a "default" value from gSavedSettings.getS32("FlashCount")).
// Likewise, missing "p.button_flash_rate" is replaced by gSavedSettings.getF32("FlashPeriod").
// Note: flashing should be allowed in settings.xml (boolean key "EnableButtonFlashing").
S32 flash_count = p.button_flash_count.isProvided()? p.button_flash_count : 0;
F32 flash_rate = p.button_flash_rate.isProvided()? p.button_flash_rate : 0.0;
mFlashingTimer = new LLFlashTimer ((LLFlashTimer::callback_t)NULL, flash_count, flash_rate);
}
else
{
mButtonFlashCount = p.button_flash_count;
mButtonFlashRate = p.button_flash_rate;
}
static LLUICachedControl<S32> llbutton_orig_h_pad ("UIButtonOrigHPad", 0);
static Params default_params(LLUICtrlFactory::getDefaultParams<LLButton>());
if (!p.label_selected.isProvided())
{
mSelectedLabel = mUnselectedLabel;
}
// Hack to make sure there is space for at least one character
if (getRect().getWidth() - (mRightHPad + mLeftHPad) < mGLFont->getWidth(std::string(" ")))
{
// Use old defaults
mLeftHPad = llbutton_orig_h_pad;
mRightHPad = llbutton_orig_h_pad;
}
mMouseDownTimer.stop();
// if custom unselected button image provided...
if (p.image_unselected != default_params.image_unselected)
{
//...fade it out for disabled image by default...
if (p.image_disabled() == default_params.image_disabled() )
{
mImageDisabled = p.image_unselected;
mFadeWhenDisabled = TRUE;
}
if (p.image_pressed_selected == default_params.image_pressed_selected)
{
mImagePressedSelected = mImageUnselected;
}
}
// if custom selected button image provided...
if (p.image_selected != default_params.image_selected)
{
//...fade it out for disabled image by default...
if (p.image_disabled_selected() == default_params.image_disabled_selected())
{
mImageDisabledSelected = p.image_selected;
mFadeWhenDisabled = TRUE;
}
if (p.image_pressed == default_params.image_pressed)
{
mImagePressed = mImageSelected;
}
}
if (!p.image_pressed.isProvided())
{
mImagePressed = mImageSelected;
}
if (!p.image_pressed_selected.isProvided())
{
mImagePressedSelected = mImageUnselected;
}
if (mImageUnselected.isNull())
{
LL_WARNS() << "Button: " << getName() << " with no image!" << LL_ENDL;
}
if (p.click_callback.isProvided())
{
setCommitCallback(initCommitCallback(p.click_callback)); // alias -> commit_callback
}
if (p.mouse_down_callback.isProvided())
{
setMouseDownCallback(initCommitCallback(p.mouse_down_callback));
}
if (p.mouse_up_callback.isProvided())
{
setMouseUpCallback(initCommitCallback(p.mouse_up_callback));
}
if (p.mouse_held_callback.isProvided())
{
setHeldDownCallback(initCommitCallback(p.mouse_held_callback));
}
if (p.badge.isProvided())
{
LLBadgeOwner::initBadgeParams(p.badge());
}
}
boost::signals2::connection LLAccordionCtrlTab::setDropDownStateChangedCallback(commit_callback_t cb)
{
return setCommitCallback(cb);
}
BOOL wlfPanel_AdvSettings::postBuild()
{
setVisible(true);
if (LLUICtrl* ctrl = findChild<LLUICtrl>("expand"))
ctrl->setCommitCallback(boost::bind(&wlfPanel_AdvSettings::onClickExpandBtn, this));
if (mExpanded)
{
// Windlight
getChild<LLCheckBoxCtrl>("use_estate_wl")->setCommitCallback(boost::bind(&wlfPanel_AdvSettings::onUseRegionSettings, this, _2));
auto mPostProcessPresetCombo = getChild<LLComboBox>("PostProcessPresetsCombo");
mPostProcessPresetCombo->setCommitCallback(boost::bind(&LLPostProcess::setSelectedEffect, LLPostProcess::getInstance(), boost::bind(&LLSD::asStringRef, _2)));
mWaterPresetCombo = getChild<LLComboBox>("WLWaterPresetsCombo");
mWaterPresetCombo->setCommitCallback(boost::bind(&wlfPanel_AdvSettings::onChangeWWPresetName, this, _2));
mSkyPresetCombo = getChild<LLComboBox>("WLSkyPresetsCombo");
mSkyPresetCombo->setCommitCallback(boost::bind(&wlfPanel_AdvSettings::onChangeWLPresetName, this, _2));
// mDayCyclePresetCombo = getChild<LLComboBox>("DCPresetsCombo");
// mDayCyclePresetCombo->setCommitCallback(boost::bind(&wlfPanel_AdvSettings::onChangeDCPresetName, this, _2));
void populatePostProcessList(LLComboBox* comboBox);
mConnections.push_front(new boost::signals2::scoped_connection(LLPostProcess::instance().setSelectedEffectChangeCallback(boost::bind(populatePostProcessList, mPostProcessPresetCombo))));
mConnections.push_front(new boost::signals2::scoped_connection(LLEnvManagerNew::instance().setPreferencesChangeCallback(boost::bind(&wlfPanel_AdvSettings::refreshLists, this))));
mConnections.push_front(new boost::signals2::scoped_connection(LLWaterParamManager::getInstance()->setPresetListChangeCallback(boost::bind(&wlfPanel_AdvSettings::populateWaterPresetsList, this))));
mConnections.push_front(new boost::signals2::scoped_connection(LLWLParamManager::getInstance()->setPresetListChangeCallback(boost::bind(&wlfPanel_AdvSettings::populateSkyPresetsList, this))));
// LLDayCycleManager::instance().setModifyCallback(boost::bind(&wlfPanel_AdvSettings::populateDayCyclePresetsList, this));
populatePostProcessList(mPostProcessPresetCombo);
populateWaterPresetsList();
populateSkyPresetsList();
//populateDayCyclePresetsList();
// next/prev buttons
getChild<LLUICtrl>("PPnext")->setCommitCallback(boost::bind(wlfPanel_AdvSettings::onClickArrow, mPostProcessPresetCombo, true));
getChild<LLUICtrl>("PPprev")->setCommitCallback(boost::bind(wlfPanel_AdvSettings::onClickArrow, mPostProcessPresetCombo, false));
getChild<LLUICtrl>("WWnext")->setCommitCallback(boost::bind(wlfPanel_AdvSettings::onClickArrow, mWaterPresetCombo, true));
getChild<LLUICtrl>("WWprev")->setCommitCallback(boost::bind(wlfPanel_AdvSettings::onClickArrow, mWaterPresetCombo, false));
getChild<LLUICtrl>("WLnext")->setCommitCallback(boost::bind(wlfPanel_AdvSettings::onClickArrow, mSkyPresetCombo, true));
getChild<LLUICtrl>("WLprev")->setCommitCallback(boost::bind(wlfPanel_AdvSettings::onClickArrow, mSkyPresetCombo, false));
getChild<LLUICtrl>("PostProcessButton")->setCommitCallback(boost::bind(LLFloaterPostProcess::toggleInstance, LLSD()));
getChild<LLUICtrl>("EnvAdvancedSkyButton")->setCommitCallback(boost::bind(LLFloaterWindLight::show));
getChild<LLUICtrl>("EnvAdvancedWaterButton")->setCommitCallback(boost::bind(LLFloaterWater::show));
mTimeSlider = getChild<LLSliderCtrl>("EnvTimeSlider");
mTimeSlider->setCommitCallback(boost::bind(&wlfPanel_AdvSettings::onChangeDayTime, this, _2));
updateTimeSlider();
updateRlvVisibility();
// Camera Presets
const U32 preset(gSavedSettings.getU32("CameraPreset"));
if (preset == CAMERA_PRESET_REAR_VIEW)
getChildView("Rear")->setValue(true);
else if (preset == CAMERA_PRESET_FRONT_VIEW)
getChildView("Front")->setValue(true);
else if (preset == CAMERA_PRESET_GROUP_VIEW)
getChildView("Group")->setValue(true);
// Hover height
mHoverHeight = getChild<LLSliderCtrl>("HoverHeightSlider");
mHoverHeight->setMinValue(MIN_HOVER_Z);
mHoverHeight->setMaxValue(MAX_HOVER_Z);
mHoverHeight->setSliderMouseUpCallback(boost::bind(onHoverSliderFinalCommit, _2));
mHoverHeight->setSliderEditorCommitCallback(boost::bind(onHoverSliderFinalCommit, _2));
mHoverHeight->setCommitCallback(boost::bind(onHoverSliderMoved, _2));
// Initialize slider from pref setting.
syncFromPreferenceSetting(mHoverHeight);
// Update slider on future pref changes.
if (LLControlVariable* control = gSavedPerAccountSettings.getControl("AvatarHoverOffsetZ"))
{
control->getCommitSignal()->connect(boost::bind(&syncFromPreferenceSetting, mHoverHeight));
}
else
{
LL_WARNS() << "Control not found for AvatarHoverOffsetZ" << LL_ENDL;
}
updateEditHoverEnabled();
if (!mRegionChangedSlot.connected())
{
mRegionChangedSlot = gAgent.addRegionChangedCallback(boost::bind(&wlfPanel_AdvSettings::onRegionChanged, this));
}
// Set up based on initial region.
onRegionChanged();
}
else
{
mHoverHeight = nullptr;
}
return TRUE;
}
boost::signals2::connection LLUICtrl::setCommitCallback(const CommitCallbackParam& cb)
{
return setCommitCallback(initCommitCallback(cb));
}
boost::signals2::connection LLPanelAvatarTag::setLeftButtonClickCallback(
const commit_callback_t& cb)
{
return setCommitCallback(cb);
}
