/** * @file lluictrl.cpp * @author James Cook, Richard Nelson, Tom Yedwab * @brief Abstract base class for UI controls * * $LicenseInfo:firstyear=2001&license=viewergpl$ * * Copyright (c) 2001-2009, Linden Research, Inc. * * Second Life Viewer Source Code * The source code in this file ("Source Code") is provided by Linden Lab * to you under the terms of the GNU General Public License, version 2.0 * ("GPL"), unless you have obtained a separate licensing agreement * ("Other License"), formally executed by you and Linden Lab. Terms of * the GPL can be found in doc/GPL-license.txt in this distribution, or * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 * * There are special exceptions to the terms and conditions of the GPL as * it is applied to this Source Code. View the full text of the exception * in the file doc/FLOSS-exception.txt in this software distribution, or * online at * http://secondlifegrid.net/programs/open_source/licensing/flossexception * * By copying, modifying or distributing this software, you acknowledge * that you have read and understood your obligations described above, * and agree to abide by those obligations. * * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, * COMPLETENESS OR PERFORMANCE. * $/LicenseInfo$ */ #include "linden_common.h" #define LLUICTRL_CPP #include "lluictrl.h" #include "llfocusmgr.h" #include "llpanel.h" #include "lluictrlfactory.h" static LLDefaultChildRegistry::Register<LLUICtrl> r("ui_ctrl"); // Compiler optimization, generate extern template template class LLUICtrl* LLView::getChild<class LLUICtrl>( const std::string& name, BOOL recurse) const; LLUICtrl::CallbackParam::CallbackParam() : name("name"), function_name("function"), parameter("parameter"), control_name("control") // Shortcut to control -> "control_name" for backwards compatability { addSynonym(parameter, "userdata"); } LLUICtrl::EnableControls::EnableControls() : enabled("enabled_control"), disabled("disabled_control") {} LLUICtrl::ControlVisibility::ControlVisibility() : visible("visibility_control"), invisible("invisibility_control") { addSynonym(visible, "visiblity_control"); addSynonym(invisible, "invisiblity_control"); } LLUICtrl::Params::Params() : tab_stop("tab_stop", true), chrome("chrome", false), label("label"), initial_value("value"), init_callback("init_callback"), commit_callback("commit_callback"), validate_callback("validate_callback"), mouseenter_callback("mouseenter_callback"), mouseleave_callback("mouseleave_callback"), control_name("control_name"), font("font", LLFontGL::getFontSansSerif()), font_halign("halign"), font_valign("valign"), length("length"), // ignore LLXMLNode cruft type("type") // ignore LLXMLNode cruft { addSynonym(initial_value, "initial_value"); } // NOTE: the LLFocusableElement implementation has been moved from here to llfocusmgr.cpp. //static const LLUICtrl::Params& LLUICtrl::getDefaultParams() { return LLUICtrlFactory::getDefaultParams<LLUICtrl>(); } LLUICtrl::LLUICtrl(const LLUICtrl::Params& p, const LLViewModelPtr& viewmodel) : LLView(p), mTentative(FALSE), mIsChrome(FALSE), mViewModel(viewmodel), mControlVariable(NULL), mEnabledControlVariable(NULL), mDisabledControlVariable(NULL), mMakeVisibleControlVariable(NULL), mMakeInvisibleControlVariable(NULL), mCommitSignal(NULL), mValidateSignal(NULL), mMouseEnterSignal(NULL), mMouseLeaveSignal(NULL), mMouseDownSignal(NULL), mMouseUpSignal(NULL), mRightMouseDownSignal(NULL), mRightMouseUpSignal(NULL), mDoubleClickSignal(NULL) { mUICtrlHandle.bind(this); } 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)); } } LLUICtrl::~LLUICtrl() { gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit() if( gFocusMgr.getTopCtrl() == this ) { llwarns << "UI Control holding top ctrl deleted: " << getName() << ". Top view removed." << llendl; gFocusMgr.removeTopCtrlWithoutCallback( this ); } delete mCommitSignal; delete mValidateSignal; delete mMouseEnterSignal; delete mMouseLeaveSignal; delete mMouseDownSignal; delete mMouseUpSignal; delete mRightMouseDownSignal; delete mRightMouseUpSignal; delete mDoubleClickSignal; } void default_commit_handler(LLUICtrl* ctrl, const LLSD& param) {} bool default_enable_handler(LLUICtrl* ctrl, const LLSD& param) { return true; } LLUICtrl::commit_signal_t::slot_type LLUICtrl::initCommitCallback(const CommitCallbackParam& cb) { if (cb.function.isProvided()) { if (cb.parameter.isProvided()) return boost::bind(cb.function(), _1, cb.parameter); else return cb.function(); } else { std::string function_name = cb.function_name; commit_callback_t* func = (CommitCallbackRegistry::getValue(function_name)); if (func) { if (cb.parameter.isProvided()) return boost::bind((*func), _1, cb.parameter); else return commit_signal_t::slot_type(*func); } else if (!function_name.empty()) { llwarns << "No callback found for: '" << function_name << "' in control: " << getName() << llendl; } } return default_commit_handler; } LLUICtrl::enable_signal_t::slot_type LLUICtrl::initEnableCallback(const EnableCallbackParam& cb) { // Set the callback function if (cb.function.isProvided()) { if (cb.parameter.isProvided()) return boost::bind(cb.function(), this, cb.parameter); else return cb.function(); } else { enable_callback_t* func = (EnableCallbackRegistry::getValue(cb.function_name)); if (func) { if (cb.parameter.isProvided()) return boost::bind((*func), this, cb.parameter); else return enable_signal_t::slot_type(*func); } } return default_enable_handler; } // virtual void LLUICtrl::onMouseEnter(S32 x, S32 y, MASK mask) { if (mMouseEnterSignal) { (*mMouseEnterSignal)(this, getValue()); } } // virtual void LLUICtrl::onMouseLeave(S32 x, S32 y, MASK mask) { if(mMouseLeaveSignal) { (*mMouseLeaveSignal)(this, getValue()); } } //virtual BOOL LLUICtrl::handleMouseDown(S32 x, S32 y, MASK mask) { BOOL handled = LLView::handleMouseDown(x,y,mask); if (mMouseDownSignal) { (*mMouseDownSignal)(this,x,y,mask); } return handled; } //virtual BOOL LLUICtrl::handleMouseUp(S32 x, S32 y, MASK mask) { BOOL handled = LLView::handleMouseUp(x,y,mask); if (mMouseUpSignal) { (*mMouseUpSignal)(this,x,y,mask); } return handled; } //virtual BOOL LLUICtrl::handleRightMouseDown(S32 x, S32 y, MASK mask) { BOOL handled = LLView::handleRightMouseDown(x,y,mask); if (mRightMouseDownSignal) { (*mRightMouseDownSignal)(this,x,y,mask); } return handled; } //virtual BOOL LLUICtrl::handleRightMouseUp(S32 x, S32 y, MASK mask) { BOOL handled = LLView::handleRightMouseUp(x,y,mask); if(mRightMouseUpSignal) { (*mRightMouseUpSignal)(this,x,y,mask); } return handled; } BOOL LLUICtrl::handleDoubleClick(S32 x, S32 y, MASK mask) { BOOL handled = LLView::handleDoubleClick(x, y, mask); if (mDoubleClickSignal) { (*mDoubleClickSignal)(this, x, y, mask); } return handled; } // can't tab to children of a non-tab-stop widget BOOL LLUICtrl::canFocusChildren() const { return hasTabStop(); } void LLUICtrl::onCommit() { if (mCommitSignal) (*mCommitSignal)(this, getValue()); } //virtual BOOL LLUICtrl::isCtrl() const { return TRUE; } //virtual void LLUICtrl::setValue(const LLSD& value) { mViewModel->setValue(value); } //virtual LLSD LLUICtrl::getValue() const { return mViewModel->getValue(); } /// When two widgets are displaying the same data (e.g. during a skin /// change), share their ViewModel. void LLUICtrl::shareViewModelFrom(const LLUICtrl& other) { // Because mViewModel is an LLViewModelPtr, this assignment will quietly // dispose of the previous LLViewModel -- unless it's already shared by // somebody else. mViewModel = other.mViewModel; } //virtual LLViewModel* LLUICtrl::getViewModel() const { return mViewModel; } bool LLUICtrl::setControlValue(const LLSD& value) { if (mControlVariable) { mControlVariable->set(value); return true; } return false; } void LLUICtrl::setControlVariable(LLControlVariable* control) { if (mControlVariable) { //RN: this will happen in practice, should we try to avoid it? //llwarns << "setControlName called twice on same control!" << llendl; mControlConnection.disconnect(); // disconnect current signal mControlVariable = NULL; } if (control) { mControlVariable = control; mControlConnection = mControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("value"))); setValue(mControlVariable->getValue()); } } //virtual void LLUICtrl::setControlName(const std::string& control_name, LLView *context) { if (context == NULL) { context = this; } // Register new listener if (!control_name.empty()) { LLControlVariable* control = context->findControl(control_name); setControlVariable(control); } } void LLUICtrl::setEnabledControlVariable(LLControlVariable* control) { if (mEnabledControlVariable) { mEnabledControlConnection.disconnect(); // disconnect current signal mEnabledControlVariable = NULL; } if (control) { mEnabledControlVariable = control; mEnabledControlConnection = mEnabledControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("enabled"))); setEnabled(mEnabledControlVariable->getValue().asBoolean()); } } void LLUICtrl::setDisabledControlVariable(LLControlVariable* control) { if (mDisabledControlVariable) { mDisabledControlConnection.disconnect(); // disconnect current signal mDisabledControlVariable = NULL; } if (control) { mDisabledControlVariable = control; mDisabledControlConnection = mDisabledControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("disabled"))); setEnabled(!(mDisabledControlVariable->getValue().asBoolean())); } } void LLUICtrl::setMakeVisibleControlVariable(LLControlVariable* control) { if (mMakeVisibleControlVariable) { mMakeVisibleControlConnection.disconnect(); // disconnect current signal mMakeVisibleControlVariable = NULL; } if (control) { mMakeVisibleControlVariable = control; mMakeVisibleControlConnection = mMakeVisibleControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("visible"))); setVisible(mMakeVisibleControlVariable->getValue().asBoolean()); } } void LLUICtrl::setMakeInvisibleControlVariable(LLControlVariable* control) { if (mMakeInvisibleControlVariable) { mMakeInvisibleControlConnection.disconnect(); // disconnect current signal mMakeInvisibleControlVariable = NULL; } if (control) { mMakeInvisibleControlVariable = control; mMakeInvisibleControlConnection = mMakeInvisibleControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("invisible"))); setVisible(!(mMakeInvisibleControlVariable->getValue().asBoolean())); } } // static bool LLUICtrl::controlListener(const LLSD& newvalue, LLHandle<LLUICtrl> handle, std::string type) { LLUICtrl* ctrl = handle.get(); if (ctrl) { if (type == "value") { ctrl->setValue(newvalue); return true; } else if (type == "enabled") { ctrl->setEnabled(newvalue.asBoolean()); return true; } else if(type =="disabled") { ctrl->setEnabled(!newvalue.asBoolean()); return true; } else if (type == "visible") { ctrl->setVisible(newvalue.asBoolean()); return true; } else if (type == "invisible") { ctrl->setVisible(!newvalue.asBoolean()); return true; } } return false; } // virtual BOOL LLUICtrl::setTextArg( const std::string& key, const LLStringExplicit& text ) { return FALSE; } // virtual BOOL LLUICtrl::setLabelArg( const std::string& key, const LLStringExplicit& text ) { return FALSE; } // virtual LLCtrlSelectionInterface* LLUICtrl::getSelectionInterface() { return NULL; } // virtual LLCtrlListInterface* LLUICtrl::getListInterface() { return NULL; } // virtual LLCtrlScrollInterface* LLUICtrl::getScrollInterface() { return NULL; } BOOL LLUICtrl::hasFocus() const { return (gFocusMgr.childHasKeyboardFocus(this)); } void LLUICtrl::setFocus(BOOL b) { // focus NEVER goes to ui ctrls that are disabled! if (!getEnabled()) { return; } if( b ) { if (!hasFocus()) { gFocusMgr.setKeyboardFocus( this ); } } else { if( gFocusMgr.childHasKeyboardFocus(this)) { gFocusMgr.setKeyboardFocus( NULL ); } } } // virtual void LLUICtrl::setTabStop( BOOL b ) { mTabStop = b; } // virtual BOOL LLUICtrl::hasTabStop() const { return mTabStop; } // virtual BOOL LLUICtrl::acceptsTextInput() const { return FALSE; } //virtual BOOL LLUICtrl::isDirty() const { return mViewModel->isDirty(); }; //virtual void LLUICtrl::resetDirty() { mViewModel->resetDirty(); } // virtual void LLUICtrl::onTabInto() { } // virtual void LLUICtrl::clear() { } // virtual void LLUICtrl::setIsChrome(BOOL is_chrome) { mIsChrome = is_chrome; } // virtual BOOL LLUICtrl::getIsChrome() const { LLView* parent_ctrl = getParent(); while(parent_ctrl) { if(parent_ctrl->isCtrl()) { break; } parent_ctrl = parent_ctrl->getParent(); } if(parent_ctrl) { return mIsChrome || ((LLUICtrl*)parent_ctrl)->getIsChrome(); } else { return mIsChrome ; } } // this comparator uses the crazy disambiguating logic of LLCompareByTabOrder, // but to switch up the order so that children that have the default tab group come first // and those that are prior to the default tab group come last class CompareByDefaultTabGroup: public LLCompareByTabOrder { public: CompareByDefaultTabGroup(LLView::child_tab_order_t order, S32 default_tab_group): LLCompareByTabOrder(order), mDefaultTabGroup(default_tab_group) {} private: /*virtual*/ bool compareTabOrders(const LLView::tab_order_t & a, const LLView::tab_order_t & b) const { S32 ag = a.first; // tab group for a S32 bg = b.first; // tab group for b // these two ifs have the effect of moving elements prior to the default tab group to the end of the list // (still sorted relative to each other, though) if(ag < mDefaultTabGroup && bg >= mDefaultTabGroup) return false; if(bg < mDefaultTabGroup && ag >= mDefaultTabGroup) return true; return a < b; // sort correctly if they're both on the same side of the default tab group } S32 mDefaultTabGroup; }; // Sorter for plugging into the query. // I'd have defined it local to the one method that uses it but that broke the VS 05 compiler. -MG class LLUICtrl::DefaultTabGroupFirstSorter : public LLQuerySorter, public LLSingleton<DefaultTabGroupFirstSorter> { public: /*virtual*/ void operator() (LLView * parent, viewList_t &children) const { children.sort(CompareByDefaultTabGroup(parent->getCtrlOrder(), parent->getDefaultTabGroup())); } }; BOOL LLUICtrl::focusFirstItem(BOOL prefer_text_fields, BOOL focus_flash) { // try to select default tab group child LLCtrlQuery query = getTabOrderQuery(); // sort things such that the default tab group is at the front query.setSorter(DefaultTabGroupFirstSorter::getInstance()); child_list_t result = query(this); if(result.size() > 0) { LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front()); if(!ctrl->hasFocus()) { ctrl->setFocus(TRUE); ctrl->onTabInto(); if(focus_flash) { gFocusMgr.triggerFocusFlash(); } } return TRUE; } // search for text field first if(prefer_text_fields) { LLCtrlQuery query = getTabOrderQuery(); query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance()); child_list_t result = query(this); if(result.size() > 0) { LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front()); if(!ctrl->hasFocus()) { ctrl->setFocus(TRUE); ctrl->onTabInto(); gFocusMgr.triggerFocusFlash(); } return TRUE; } } // no text field found, or we don't care about text fields result = getTabOrderQuery().run(this); if(result.size() > 0) { LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.front()); if(!ctrl->hasFocus()) { ctrl->setFocus(TRUE); ctrl->onTabInto(); gFocusMgr.triggerFocusFlash(); } return TRUE; } return FALSE; } BOOL LLUICtrl::focusLastItem(BOOL prefer_text_fields) { // search for text field first if(prefer_text_fields) { LLCtrlQuery query = getTabOrderQuery(); query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance()); child_list_t result = query(this); if(result.size() > 0) { LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.back()); if(!ctrl->hasFocus()) { ctrl->setFocus(TRUE); ctrl->onTabInto(); gFocusMgr.triggerFocusFlash(); } return TRUE; } } // no text field found, or we don't care about text fields child_list_t result = getTabOrderQuery().run(this); if(result.size() > 0) { LLUICtrl * ctrl = static_cast<LLUICtrl*>(result.back()); if(!ctrl->hasFocus()) { ctrl->setFocus(TRUE); ctrl->onTabInto(); gFocusMgr.triggerFocusFlash(); } return TRUE; } return FALSE; } BOOL LLUICtrl::focusNextItem(BOOL text_fields_only) { // this assumes that this method is called on the focus root. LLCtrlQuery query = getTabOrderQuery(); static LLUICachedControl<bool> tab_to_text_fields_only ("TabToTextFieldsOnly", false); if(text_fields_only || tab_to_text_fields_only) { query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance()); } child_list_t result = query(this); return focusNext(result); } BOOL LLUICtrl::focusPrevItem(BOOL text_fields_only) { // this assumes that this method is called on the focus root. LLCtrlQuery query = getTabOrderQuery(); static LLUICachedControl<bool> tab_to_text_fields_only ("TabToTextFieldsOnly", false); if(text_fields_only || tab_to_text_fields_only) { query.addPreFilter(LLUICtrl::LLTextInputFilter::getInstance()); } child_list_t result = query(this); return focusPrev(result); } LLUICtrl* LLUICtrl::findRootMostFocusRoot() { LLUICtrl* focus_root = NULL; LLUICtrl* next_view = this; while(next_view) { if (next_view->isFocusRoot()) { focus_root = next_view; } next_view = next_view->getParentUICtrl(); } return focus_root; } // Skip over any parents that are not LLUICtrl's // Used in focus logic since only LLUICtrl elements can have focus LLUICtrl* LLUICtrl::getParentUICtrl() const { LLView* parent = getParent(); while (parent) { if (parent->isCtrl()) { return (LLUICtrl*)(parent); } else { parent = parent->getParent(); } } return NULL; } bool LLUICtrl::findHelpTopic(std::string& help_topic_out) { LLUICtrl* ctrl = this; // search back through the control's parents for a panel // or tab with a help_topic string defined while (ctrl) { LLPanel *panel = dynamic_cast<LLPanel *>(ctrl); if (panel) { // does the panel have a sub-panel with a help topic? LLPanel *subpanel = panel->childGetVisiblePanelWithHelp(); if (subpanel) { help_topic_out = subpanel->getHelpTopic(); return true; // success (subpanel) } // does the panel have an active tab with a help topic? LLPanel *tab = panel->childGetVisibleTabWithHelp(); if (tab) { help_topic_out = tab->getHelpTopic(); return true; // success (tab) } // otherwise, does the panel have a help topic itself? if (!panel->getHelpTopic().empty()) { help_topic_out = panel->getHelpTopic(); return true; // success (panel) } } ctrl = ctrl->getParentUICtrl(); } return false; // no help topic found } // *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)); } boost::signals2::connection LLUICtrl::setValidateBeforeCommit( boost::function<bool (const LLSD& data)> cb ) { if (!mValidateSignal) mValidateSignal = new enable_signal_t(); return mValidateSignal->connect(boost::bind(cb, _2)); } // virtual void LLUICtrl::setTentative(BOOL b) { mTentative = b; } // virtual BOOL LLUICtrl::getTentative() const { return mTentative; } // virtual void LLUICtrl::setColor(const LLColor4& color) { } boost::signals2::connection LLUICtrl::setCommitCallback( const commit_signal_t::slot_type& cb ) { if (!mCommitSignal) mCommitSignal = new commit_signal_t(); return mCommitSignal->connect(cb); } boost::signals2::connection LLUICtrl::setValidateCallback( const enable_signal_t::slot_type& cb ) { if (!mValidateSignal) mValidateSignal = new enable_signal_t(); return mValidateSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseEnterCallback( const commit_signal_t::slot_type& cb ) { if (!mMouseEnterSignal) mMouseEnterSignal = new commit_signal_t(); return mMouseEnterSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseLeaveCallback( const commit_signal_t::slot_type& cb ) { if (!mMouseLeaveSignal) mMouseLeaveSignal = new commit_signal_t(); return mMouseLeaveSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseDownCallback( const mouse_signal_t::slot_type& cb ) { if (!mMouseDownSignal) mMouseDownSignal = new mouse_signal_t(); return mMouseDownSignal->connect(cb); } boost::signals2::connection LLUICtrl::setMouseUpCallback( const mouse_signal_t::slot_type& cb ) { if (!mMouseUpSignal) mMouseUpSignal = new mouse_signal_t(); return mMouseUpSignal->connect(cb); } boost::signals2::connection LLUICtrl::setRightMouseDownCallback( const mouse_signal_t::slot_type& cb ) { if (!mRightMouseDownSignal) mRightMouseDownSignal = new mouse_signal_t(); return mRightMouseDownSignal->connect(cb); } boost::signals2::connection LLUICtrl::setRightMouseUpCallback( const mouse_signal_t::slot_type& cb ) { if (!mRightMouseUpSignal) mRightMouseUpSignal = new mouse_signal_t(); return mRightMouseUpSignal->connect(cb); } boost::signals2::connection LLUICtrl::setDoubleClickCallback( const mouse_signal_t::slot_type& cb ) { if (!mDoubleClickSignal) mDoubleClickSignal = new mouse_signal_t(); return mDoubleClickSignal->connect(cb); }