Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate to boost::bind for a bunch of CommitCallbacks. Converted several static member functions to nonstatic member functions

Browse Source
This commit is contained in:
Shyotl
2012-12-06 17:13:17 -06:00
parent ef6f411b70
commit 26191dd274
27 changed files with 326 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
indra/llcharacter/llmultigesture.cpp
View File

@@ -50,8 +50,7 @@ LLMultiGesture::LLMultiGesture()
mSteps(),
mPlaying(FALSE),
mCurrentStep(0),
mDoneCallback(NULL),
mCallbackData(NULL)
mDoneCallback(NULL)
{
reset();
}

3
indra/llcharacter/llmultigesture.h
View File

@@ -100,8 +100,7 @@ public:
// Timer for waiting
LLFrameTimer mWaitTimer;
void (*mDoneCallback)(LLMultiGesture* gesture, void* data);
void* mCallbackData;
boost::function<void (LLMultiGesture*)> mDoneCallback;
// Animations that we requested to start
std::set<LLUUID> mRequestedAnimIDs;

48
indra/newview/floaterao.cpp
View File

@@ -356,9 +356,9 @@ BOOL LLFloaterAO::postBuild()
childSetAction("newcard",onClickNewCard,this);
childSetAction("prevstand",onClickPrevStand,this);
childSetAction("nextstand",onClickNextStand,this);
childSetCommitCallback("AOEnabled",onClickToggleAO);
childSetCommitCallback("AOSitsEnabled",onClickToggleSits);
childSetCommitCallback("standtime",onSpinnerCommit);
getChild<LLComboBox>("AOEnabled")->setCommitCallback(boost::bind(&LLFloaterAO::onClickToggleAO));
getChild<LLComboBox>("AOSitsEnabled")->setCommitCallback(boost::bind(&LLFloaterAO::onClickToggleSits));
getChild<LLComboBox>("standtime")->setCommitCallback(boost::bind(&LLFloaterAO::onSpinnerCommit,_1));
mcomboBox_stands = getChild<LLComboBox>("stands");
mcomboBox_walks = getChild<LLComboBox>("walks");
mcomboBox_runs = getChild<LLComboBox>("runs");
@@ -376,28 +376,28 @@ BOOL LLFloaterAO::postBuild()
mcomboBox_lands = getChild<LLComboBox>("lands");
mcomboBox_standups = getChild<LLComboBox>("standups");
mcomboBox_prejumps = getChild<LLComboBox>("prejumps");
getChild<LLComboBox>("stands")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("walks")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("runs")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("jumps")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("sits")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("gsits")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("crouchs")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("cwalks")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("falls")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("hovers")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flys")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flyslows")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flyups")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flydowns")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("lands")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("standups")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("prejumps")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("stands")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("walks")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("runs")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("jumps")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("sits")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("gsits")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("crouchs")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("cwalks")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("falls")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("hovers")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("flys")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("flyslows")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("flyups")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("flydowns")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("lands")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("standups")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
getChild<LLComboBox>("prejumps")->setCommitCallback(boost::bind(&LLFloaterAO::onComboBoxCommit,_1));
return TRUE;
}
void LLFloaterAO::onSpinnerCommit(LLUICtrl* ctrl, void* userdata)
void LLFloaterAO::onSpinnerCommit(LLUICtrl* ctrl)
{
LLSpinCtrl* spin = (LLSpinCtrl*) ctrl;
if(spin)
@@ -409,7 +409,7 @@ void LLFloaterAO::onSpinnerCommit(LLUICtrl* ctrl, void* userdata)
}
}
void LLFloaterAO::onComboBoxCommit(LLUICtrl* ctrl, void* userdata)
void LLFloaterAO::onComboBoxCommit(LLUICtrl* ctrl)
{
LLComboBox* box = (LLComboBox*)ctrl;
if(box)
@@ -727,12 +727,12 @@ void LLFloaterAO::onClickLess(void* data)
updateLayout(sInstance);
}
void LLFloaterAO::onClickToggleAO(LLUICtrl *, void*)
void LLFloaterAO::onClickToggleAO()
{
run();
}
void LLFloaterAO::onClickToggleSits(LLUICtrl *, void*)
void LLFloaterAO::onClickToggleSits()
{
run();
}

8
indra/newview/floaterao.h
View File

@@ -68,8 +68,8 @@ public:
static void show(void*);
static void init();
static void onClickToggleAO(LLUICtrl *, void*);
static void onClickToggleSits(LLUICtrl *, void*);
static void onClickToggleAO();
static void onClickToggleSits();
static void run();
static void updateLayout(LLFloaterAO* floater);
@@ -115,8 +115,8 @@ private:
static AONoteCardDropTarget* mAOItemDropTarget;
static void AOItemDrop(LLViewerInventoryItem* item);
static void onSpinnerCommit(LLUICtrl* ctrl, void* userdata);
static void onComboBoxCommit(LLUICtrl* ctrl, void* userdata);
static void onSpinnerCommit(LLUICtrl* ctrl);
static void onComboBoxCommit(LLUICtrl* ctrl);
static BOOL SetDefault(void *userdata, LLUUID ao_id, std::string defaultanim);
BOOL mDirty;

27
indra/newview/floaterlocalassetbrowse.cpp
View File

@@ -800,13 +800,13 @@ FloaterLocalAssetBrowser::FloaterLocalAssetBrowser()
mUploadBtn->setClickedCallback( onClickUpload, this);
// combo callback
mTypeComboBox->setCommitCallback(onCommitTypeCombo);
mTypeComboBox->setCommitCallback(boost::bind(&FloaterLocalAssetBrowser::onCommitTypeCombo,this));
// scrolllist callbacks
mBitmapList->setCommitCallback(onChooseBitmapList);
mBitmapList->setCommitCallback(boost::bind(&FloaterLocalAssetBrowser::onChooseBitmapList,this));
// checkbox callbacks
mUpdateChkBox->setCommitCallback(onClickUpdateChkbox);
mUpdateChkBox->setCommitCallback(boost::bind(&FloaterLocalAssetBrowser::onClickUpdateChkbox,this));
}
@@ -857,34 +857,33 @@ void FloaterLocalAssetBrowser::onClickUpload(void* userdata)
}
}
void FloaterLocalAssetBrowser::onChooseBitmapList(LLUICtrl* ctrl, void *userdata)
void FloaterLocalAssetBrowser::onChooseBitmapList()
{
bool button_status = sLFInstance->mBitmapList->isEmpty();
sLFInstance->mDelBtn->setEnabled(!button_status);
sLFInstance->mUploadBtn->setEnabled(!button_status);
bool button_status = mBitmapList->isEmpty();
mDelBtn->setEnabled(!button_status);
mUploadBtn->setEnabled(!button_status);
sLFInstance->UpdateRightSide();
UpdateRightSide();
}
void FloaterLocalAssetBrowser::onClickUpdateChkbox(LLUICtrl *ctrl, void *userdata)
void FloaterLocalAssetBrowser::onClickUpdateChkbox()
{
std::string temp_str = sLFInstance->mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID);
std::string temp_str = mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID);
if ( !temp_str.empty() )
{
gLocalBrowser->onUpdateBool( (LLUUID)temp_str );
sLFInstance->UpdateRightSide();
UpdateRightSide();
}
}
void FloaterLocalAssetBrowser::onCommitTypeCombo(LLUICtrl* ctrl, void *userdata)
void FloaterLocalAssetBrowser::onCommitTypeCombo()
{
std::string temp_str = sLFInstance->mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID);
std::string temp_str = mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID);
if ( !temp_str.empty() )
{
S32 selection = sLFInstance->mTypeComboBox->getCurrentIndex();
gLocalBrowser->onSetType( (LLUUID)temp_str, selection );
}
}

6
indra/newview/floaterlocalassetbrowse.h
View File

@@ -236,13 +236,13 @@ private:
static void onClickUpload(void* userdata);
// ScrollList callback declarations
static void onChooseBitmapList(LLUICtrl* ctrl, void* userdata);
void onChooseBitmapList();
// Checkbox callback declarations
static void onClickUpdateChkbox(LLUICtrl* ctrl, void* userdata);
void onClickUpdateChkbox();
// Combobox type select
static void onCommitTypeCombo(LLUICtrl* ctrl, void* userdata);
void onCommitTypeCombo();
// Widgets
LLButton* mAddBtn;

14
indra/newview/lldebugmessagebox.cpp
View File

@@ -112,7 +112,7 @@ void LLDebugVarMessageBox::show(const std::string& title, F32 *var, F32 max_valu
{
box->mSlider1->setValue(*var);
}
box->mSlider1->setCommitCallback(slider_changed);
box->mSlider1->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider1->setCallbackUserData(box);
#endif
}
@@ -129,8 +129,7 @@ void LLDebugVarMessageBox::show(const std::string& title, S32 *var, S32 max_valu
{
box->mSlider1->setValue((F32)*var);
}
box->mSlider1->setCommitCallback(slider_changed);
box->mSlider1->setCallbackUserData(box);
box->mSlider1->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
#endif
}
@@ -142,20 +141,17 @@ void LLDebugVarMessageBox::show(const std::string& title, LLVector3 *var, LLVect
box->mSlider1->setMaxValue(max_value.mV[VX]);
box->mSlider1->setMinValue(-max_value.mV[VX]);
box->mSlider1->setIncrement(increment.mV[VX]);
box->mSlider1->setCommitCallback(slider_changed);
box->mSlider1->setCallbackUserData(box);
box->mSlider1->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider2->setMaxValue(max_value.mV[VX]);
box->mSlider2->setMinValue(-max_value.mV[VX]);
box->mSlider2->setIncrement(increment.mV[VX]);
box->mSlider2->setCommitCallback(slider_changed);
box->mSlider2->setCallbackUserData(box);
box->mSlider2->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider3->setMaxValue(max_value.mV[VX]);
box->mSlider3->setMinValue(-max_value.mV[VX]);
box->mSlider3->setIncrement(increment.mV[VX]);
box->mSlider3->setCommitCallback(slider_changed);
box->mSlider3->setCallbackUserData(box);
box->mSlider3->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
#endif
}

10
indra/newview/llfloateractivespeakers.cpp
View File

@@ -335,7 +335,7 @@ BOOL LLPanelActiveSpeakers::postBuild()
mSpeakerList->sortByColumn(sort_column, sort_ascending);
mSpeakerList->setDoubleClickCallback(boost::bind(&onDoubleClickSpeaker,this));
mSpeakerList->setCommitOnSelectionChange(TRUE);
mSpeakerList->setCommitCallback(onSelectSpeaker);
mSpeakerList->setCommitCallback(boost::bind(&LLPanelActiveSpeakers::handleSpeakerSelect,this));
mSpeakerList->setSortChangedCallback(boost::bind(&LLPanelActiveSpeakers::onSortChanged,this));
mSpeakerList->setCallbackUserData(this);
@@ -813,14 +813,6 @@ void LLPanelActiveSpeakers::onDoubleClickSpeaker(void* user_data)
}
}
//static
void LLPanelActiveSpeakers::onSelectSpeaker(LLUICtrl* source, void* user_data)
{
LLPanelActiveSpeakers* panelp = (LLPanelActiveSpeakers*)user_data;
panelp->handleSpeakerSelect();
}
//static
void LLPanelActiveSpeakers::onSortChanged(void* user_data)
{

1
indra/newview/llfloateractivespeakers.h
View File

@@ -232,7 +232,6 @@ public:
static void onVolumeChange(LLUICtrl* source, void* user_data);
static void onClickProfile(void* user_data);
static void onDoubleClickSpeaker(void* user_data);
static void onSelectSpeaker(LLUICtrl* source, void* user_data);
static void onSortChanged(void* user_data);
static void onModeratorMuteVoice(LLUICtrl* ctrl, void* user_data);
static void onModeratorMuteText(LLUICtrl* ctrl, void* user_data);

16
indra/newview/llfloateravatarlist.cpp
View File

@@ -353,7 +353,7 @@ BOOL LLFloaterAvatarList::postBuild()
mAvatarList->sortByColumn("distance", TRUE);
mAvatarList->setCommitOnSelectionChange(TRUE);
mAvatarList->setCallbackUserData(this);
mAvatarList->setCommitCallback(onSelectName);
mAvatarList->setCommitCallback(boost::bind(&LLFloaterAvatarList::onSelectName,this));
mAvatarList->setDoubleClickCallback(boost::bind(&LLFloaterAvatarList::onClickFocus,this));
refreshAvatarList();
@@ -1753,21 +1753,19 @@ void LLFloaterAvatarList::onClickTeleport(void* userdata)
}
}
void LLFloaterAvatarList::onSelectName(LLUICtrl*, void* userdata)
void LLFloaterAvatarList::onSelectName()
{
LLFloaterAvatarList* self = (LLFloaterAvatarList*)userdata;
LLScrollListItem* item = self->mAvatarList->getFirstSelected();
LLScrollListItem* item = mAvatarList->getFirstSelected();
if (item)
{
LLUUID agent_id = item->getUUID();
LLAvatarListEntry* entry = self->getAvatarEntry(agent_id);
LLAvatarListEntry* entry = getAvatarEntry(agent_id);
if (entry)
{
BOOL enabled = entry->isDrawn();
self->childSetEnabled("focus_btn", enabled);
self->childSetEnabled("prev_in_list_btn", enabled);
self->childSetEnabled("next_in_list_btn", enabled);
childSetEnabled("focus_btn", enabled);
childSetEnabled("prev_in_list_btn", enabled);
childSetEnabled("next_in_list_btn", enabled);
}
}
}

2
indra/newview/llfloateravatarlist.h
View File

@@ -290,7 +290,7 @@ private:
static void callbackEjectFromEstate(const LLSD& notification, const LLSD& response);
static void callbackBanFromEstate(const LLSD& notification, const LLSD& response);
static void onSelectName(LLUICtrl*, void *userdata);
static void onSelectName();
static void onCommitUpdateRate(LLUICtrl*, void *userdata);
static void onClickSendKeys(void *userdata);

17
indra/newview/llfloatercolorpicker.cpp
View File

@@ -238,8 +238,7 @@ postBuild()
mApplyImmediateCheck = getChild<LLCheckBoxCtrl>("apply_immediate");
mApplyImmediateCheck->set(gSavedSettings.getBOOL("ApplyColorImmediately"));
mApplyImmediateCheck->setCommitCallback(onImmediateCheck);
mApplyImmediateCheck->setCallbackUserData(this);
mApplyImmediateCheck->setCommitCallback(boost::bind(&LLFloaterColorPicker::onImmediateCheck,this));
childSetCommitCallback("rspin", onTextCommit, (void*)this );
childSetCommitCallback("gspin", onTextCommit, (void*)this );
@@ -500,17 +499,13 @@ onTextCommit ( LLUICtrl* ctrl, void* data )
}
}
void LLFloaterColorPicker::onImmediateCheck( LLUICtrl* ctrl, void* data)
void LLFloaterColorPicker::onImmediateCheck()
{
LLFloaterColorPicker* self = ( LLFloaterColorPicker* )data;
if (self)
{
gSavedSettings.setBOOL("ApplyColorImmediately", self->mApplyImmediateCheck->get());
gSavedSettings.setBOOL("ApplyColorImmediately", mApplyImmediateCheck->get());
if (self->mApplyImmediateCheck->get())
{
LLColorSwatchCtrl::onColorChanged ( self->getSwatch (), LLColorSwatchCtrl::COLOR_CHANGE );
}
if (mApplyImmediateCheck->get())
{
LLColorSwatchCtrl::onColorChanged ( getSwatch(), LLColorSwatchCtrl::COLOR_CHANGE );
}
}

2
indra/newview/llfloatercolorpicker.h
View File

@@ -126,7 +126,7 @@ class LLFloaterColorPicker
static void onClickPipette ( void* data );
static void onTextCommit ( LLUICtrl* ctrl, void* data );
static void onHexCommit ( LLUICtrl* ctrl, void* data );
static void onImmediateCheck ( LLUICtrl* ctrl, void* data );
void onImmediateCheck();
static void onColorSelect( const LLTextureEntry& te, void *data );
private:
// turns on or off text entry commit call backs

4
indra/newview/llfloaterdaycycle.cpp
View File

@@ -156,7 +156,7 @@ void LLFloaterDayCycle::initCallbacks(void)
childSetAction("DayCycleSavePreset", onSavePreset, comboBox);
childSetAction("DayCycleDeletePreset", onDeletePreset, comboBox);
comboBox->setCommitCallback(onChangePresetName);
comboBox->setCommitCallback(boost::bind(&LLFloaterDayCycle::onChangePresetName,_1));
childSetAction("WLAddKey", onAddKey, NULL);
@@ -478,7 +478,7 @@ bool LLFloaterDayCycle::newPromptCallback(const LLSD& notification, const LLSD&
}
void LLFloaterDayCycle::onChangePresetName(LLUICtrl* ctrl, void * userData)
void LLFloaterDayCycle::onChangePresetName(LLUICtrl* ctrl)
{
LLComboBox * combo_box = static_cast<LLComboBox*>(ctrl);

2
indra/newview/llfloaterdaycycle.h
View File

@@ -117,7 +117,7 @@ public:
static bool newPromptCallback(const LLSD& notification, const LLSD& response);
/// what to do when you change the preset name
static void onChangePresetName(LLUICtrl* ctrl, void* userData);
static void onChangePresetName(LLUICtrl* ctrl);
/// toggle for Linden time
static void onUseLindenTime(void* userData);

2
indra/newview/llfloaterfriends.cpp
View File

@@ -367,7 +367,7 @@ BOOL LLPanelFriends::postBuild()
{
mFriendsList = getChild<LLScrollListCtrl>("friend_list");
mFriendsList->setCommitOnSelectionChange(TRUE);
childSetCommitCallback("friend_list", onSelectName, this);
mFriendsList->setCommitCallback(onSelectName, this);
childSetCommitCallback("buddy_group_combobox", onChangeContactGroup, this);
mFriendsList->setDoubleClickCallback(onClickIM, this);

21
indra/newview/llfloatergesture.cpp
View File

@@ -169,7 +169,7 @@ void LLFloaterGesture::show()
self->mSelectedID = LLUUID::null;
// Update button labels
onCommitList(NULL, self);
self->onCommitList();
self->open(); /*Flawfinder: ignore*/
}
@@ -214,7 +214,7 @@ void LLFloaterGesture::refreshAll()
}
// Update button labels
onCommitList(NULL, sInstance);
sInstance->onCommitList();
}
}
@@ -405,22 +405,19 @@ void LLFloaterGesture::onClickEdit(void* data)
}
}
// static
void LLFloaterGesture::onCommitList(LLUICtrl* ctrl, void* data)
void LLFloaterGesture::onCommitList()
{
LLFloaterGesture* self = (LLFloaterGesture*)data;
const LLUUID& item_id = childGetValue("gesture_list").asUUID();
const LLUUID& item_id = self->childGetValue("gesture_list").asUUID();
self->mSelectedID = item_id;
mSelectedID = item_id;
if (LLGestureMgr::instance().isGesturePlaying(item_id))
{
self->childSetVisible("play_btn", false);
self->childSetVisible("stop_btn", true);
childSetVisible("play_btn", false);
childSetVisible("stop_btn", true);
}
else
{
self->childSetVisible("play_btn", true);
self->childSetVisible("stop_btn", false);
childSetVisible("play_btn", true);
childSetVisible("stop_btn", false);
}
}

2
indra/newview/llfloatergesture.h
View File

@@ -74,7 +74,7 @@ protected:
static void onClickEdit(void* data);
static void onClickPlay(void* data);
static void onClickNew(void* data);
static void onCommitList(LLUICtrl* ctrl, void* data);
void onCommitList();
protected:
LLUUID mSelectedID;

38
indra/newview/llfloatergroups.cpp
View File

@@ -70,9 +70,6 @@ std::map<const LLUUID, LLFloaterGroupPicker*> LLFloaterGroupPicker::sInstances;
// helper functions
void init_group_list(LLScrollListCtrl* ctrl, const LLUUID& highlight_id, const std::string& none_text, U64 powers_mask = GP_ALL_POWERS);
//callbacks
void onGroupSortChanged(void* user_data);
///----------------------------------------------------------------------------
/// Class LLFloaterGroupPicker
///----------------------------------------------------------------------------
@@ -128,7 +125,8 @@ BOOL LLFloaterGroupPicker::postBuild()
{
const std::string none_text = getString("none");
init_group_list(getChild<LLScrollListCtrl>("group list"), gAgent.getGroupID(), none_text, mPowersMask);
LLScrollListCtrl* group_list = getChild<LLScrollListCtrl>("group list");
init_group_list(group_list, gAgent.getGroupID(), none_text, mPowersMask);
childSetAction("OK", onBtnOK, this);
@@ -213,15 +211,14 @@ void LLPanelGroups::reset()
BOOL LLPanelGroups::postBuild()
{
childSetCommitCallback("group list", onGroupList, this);
childSetTextArg("groupcount", "[COUNT]", llformat("%d",gAgent.mGroups.count()));
childSetTextArg("groupcount", "[MAX]", llformat("%d", gHippoLimits->getMaxAgentGroups()));
const std::string none_text = getString("none");
LLScrollListCtrl *group_list = getChild<LLScrollListCtrl>("group list");
init_group_list(group_list, gAgent.getGroupID(), none_text);
group_list->setSortChangedCallback(boost::bind(&onGroupSortChanged,this)); //Force 'none' to always be first entry.
group_list->setCommitCallback(boost::bind(&LLPanelGroups::onGroupList,this));
group_list->setSortChangedCallback(boost::bind(&LLPanelGroups::onGroupSortChanged,this)); //Force 'none' to always be first entry.
group_list->setDoubleClickCallback(boost::bind(&LLPanelGroups::onBtnIM,this));
childSetAction("Activate", onBtnActivate, this);
@@ -475,15 +472,20 @@ bool LLPanelGroups::callbackLeaveGroup(const LLSD& notification, const LLSD& res
return false;
}
void LLPanelGroups::onGroupList(LLUICtrl* ctrl, void* userdata)
void LLPanelGroups::onGroupSortChanged()
{
LLPanelGroups *self = (LLPanelGroups*)userdata;
if(!self)
LLScrollListCtrl *group_list = getChild<LLScrollListCtrl>("group list");
if(!group_list)
return;
self->enableButtons();
group_list->moveToFront(group_list->getItemIndex(LLUUID::null));
}
LLScrollListCtrl *group_list = (LLScrollListCtrl*)self->getChild<LLScrollListCtrl>("group list");
void LLPanelGroups::onGroupList()
{
enableButtons();
LLScrollListCtrl *group_list = getChild<LLScrollListCtrl>("group list");
if(!group_list)
return;
@@ -558,18 +560,6 @@ LLSD create_group_element(const LLGroupData *group_datap, const LLUUID &active_g
return element;
}
void onGroupSortChanged(void* user_data)
{
LLPanelGroups *panel = (LLPanelGroups*)user_data;
if(!panel)
return;
LLScrollListCtrl *group_list = (LLScrollListCtrl*)panel->getChild<LLScrollListCtrl>("group list");
if(!group_list)
return;
group_list->moveToFront(group_list->getItemIndex(LLUUID::null));
}
void init_group_list(LLScrollListCtrl* ctrl, const LLUUID& highlight_id, const std::string& none_text, U64 powers_mask)
{
S32 count = gAgent.mGroups.count();

3
indra/newview/llfloatergroups.h
View File

@@ -103,7 +103,8 @@ protected:
// highlight_id is a group id to highlight
void enableButtons();
static void onGroupList(LLUICtrl* ctrl, void* userdata);
void onGroupSortChanged();
void onGroupList();
static void onBtnCreate(void* userdata);
static void onBtnActivate(void* userdata);
static void onBtnInfo(void* userdata);

25
indra/newview/llfloaterland.cpp
View File

@@ -1125,7 +1125,7 @@ BOOL LLPanelLandObjects::postBuild()
mOwnerList = getChild<LLNameListCtrl>("owner list");
mOwnerList->sortByColumnIndex(3, FALSE);
childSetCommitCallback("owner list", onCommitList, this);
mOwnerList->setCommitCallback(boost::bind(&LLPanelLandObjects::onCommitList,this));
mOwnerList->setDoubleClickCallback(boost::bind(&LLPanelLandObjects::onDoubleClickOwner, this));
return TRUE;
@@ -1621,16 +1621,13 @@ void LLPanelLandObjects::processParcelObjectOwnersReply(LLMessageSystem *msg, vo
}
}
// static
void LLPanelLandObjects::onCommitList(LLUICtrl* ctrl, void* data)
void LLPanelLandObjects::onCommitList()
{
LLPanelLandObjects* self = (LLPanelLandObjects*)data;
if (FALSE == self->mOwnerList->getCanSelect())
if (FALSE == mOwnerList->getCanSelect())
{
return;
}
LLScrollListItem *item = self->mOwnerList->getFirstSelected();
LLScrollListItem *item = mOwnerList->getFirstSelected();
if (item)
{
// Look up the selected name, for future dialog box use.
@@ -1641,19 +1638,19 @@ void LLPanelLandObjects::onCommitList(LLUICtrl* ctrl, void* data)
return;
}
// Is this a group?
self->mSelectedIsGroup = cell->getValue().asString() == OWNER_GROUP;
mSelectedIsGroup = cell->getValue().asString() == OWNER_GROUP;
cell = item->getColumn(2);
self->mSelectedName = cell->getValue().asString();
mSelectedName = cell->getValue().asString();
cell = item->getColumn(3);
self->mSelectedCount = atoi(cell->getValue().asString().c_str());
mSelectedCount = atoi(cell->getValue().asString().c_str());
// Set the selection, and enable the return button.
self->mSelectedOwners.clear();
self->mSelectedOwners.insert(item->getUUID());
self->mBtnReturnOwnerList->setEnabled(TRUE);
mSelectedOwners.clear();
mSelectedOwners.insert(item->getUUID());
mBtnReturnOwnerList->setEnabled(TRUE);
// Highlight this user's objects
clickShowCore(self, RT_LIST, &(self->mSelectedOwners));
clickShowCore(this, RT_LIST, &(mSelectedOwners));
}
}

2
indra/newview/llfloaterland.h
View File

@@ -274,7 +274,7 @@ public:
static void onDoubleClickOwner(void*);
static void onCommitList(LLUICtrl* ctrl, void* data);
void onCommitList();
static void onLostFocus(LLFocusableElement* caller, void* user_data);
static void onCommitClean(LLUICtrl* caller, void* user_data);
static void processParcelObjectOwnersReply(LLMessageSystem *msg, void **);

2
indra/newview/llpaneldirland.cpp
View File

@@ -111,7 +111,7 @@ BOOL LLPanelDirLand::postBuild()
LLScrollListCtrl* results = getChild<LLScrollListCtrl>("results");
if (results)
{
results->setSortChangedCallback(onClickSort);
results->setSortChangedCallback(boost::bind(&LLPanelDirLand::onClickSort,this));
results->sortByColumn(mCurrentSortColumn,mCurrentSortAscending);
LLStringUtil::format_map_t args;

79
indra/newview/llpanelgroupgeneral.cpp
View File

@@ -118,18 +118,16 @@ BOOL LLPanelGroupGeneral::postBuild()
mInsignia = getChild<LLTextureCtrl>("insignia", recurse);
if (mInsignia)
{
mInsignia->setCommitCallback(onCommitAny);
mInsignia->setCallbackUserData(this);
mInsignia->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitAny,this));
mDefaultIconID = mInsignia->getImageAssetID();
}
mEditCharter = getChild<LLTextEditor>("charter", recurse);
if(mEditCharter)
{
mEditCharter->setCommitCallback(onCommitAny);
mEditCharter->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitAny,this));
mEditCharter->setFocusReceivedCallback(boost::bind(&LLPanelGroupGeneral::onFocusEdit, this));
mEditCharter->setFocusChangedCallback(boost::bind(&LLPanelGroupGeneral::onFocusEdit, this));
mEditCharter->setCallbackUserData(this);
}
mBtnJoinGroup = getChild<LLButton>("join_button", recurse);
@@ -163,16 +161,14 @@ BOOL LLPanelGroupGeneral::postBuild()
mCtrlShowInGroupList = getChild<LLCheckBoxCtrl>("show_in_group_list", recurse);
if (mCtrlShowInGroupList)
{
mCtrlShowInGroupList->setCommitCallback(&LLPanelGroupGeneral::onCommitAny);
mCtrlShowInGroupList->setCallbackUserData(this);
mCtrlShowInGroupList->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitAny,this));
}
mComboMature = getChild<LLComboBox>("group_mature_check", recurse);
if(mComboMature)
{
mComboMature->setCurrentByIndex(0);
mComboMature->setCommitCallback(onCommitAny);
mComboMature->setCallbackUserData(this);
mComboMature->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitAny,this));
if (gAgent.isTeen())
{
// Teens don't get to set mature flag. JC
@@ -183,23 +179,20 @@ BOOL LLPanelGroupGeneral::postBuild()
mCtrlOpenEnrollment = getChild<LLCheckBoxCtrl>("open_enrollement", recurse);
if (mCtrlOpenEnrollment)
{
mCtrlOpenEnrollment->setCommitCallback(onCommitAny);
mCtrlOpenEnrollment->setCallbackUserData(this);
mCtrlOpenEnrollment->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitAny,this));
}
mCtrlEnrollmentFee = getChild<LLCheckBoxCtrl>("check_enrollment_fee", recurse);
if (mCtrlEnrollmentFee)
{
mCtrlEnrollmentFee->setLabelArg("[CURRENCY]", gHippoGridManager->getConnectedGrid()->getCurrencySymbol());
mCtrlEnrollmentFee->setCommitCallback(onCommitEnrollment);
mCtrlEnrollmentFee->setCallbackUserData(this);
mCtrlEnrollmentFee->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitEnrollment,this));
}
mSpinEnrollmentFee = getChild<LLSpinCtrl>("spin_enrollment_fee", recurse);
if (mSpinEnrollmentFee)
{
mSpinEnrollmentFee->setCommitCallback(onCommitAny);
mSpinEnrollmentFee->setCallbackUserData(this);
mSpinEnrollmentFee->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitAny,this));
mSpinEnrollmentFee->setPrecision(0);
mSpinEnrollmentFee->resetDirty();
}
@@ -215,8 +208,7 @@ BOOL LLPanelGroupGeneral::postBuild()
mCtrlReceiveNotices = getChild<LLCheckBoxCtrl>("receive_notices", recurse);
if (mCtrlReceiveNotices)
{
mCtrlReceiveNotices->setCommitCallback(onCommitUserOnly);
mCtrlReceiveNotices->setCallbackUserData(this);
mCtrlReceiveNotices->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitUserOnly,this));
mCtrlReceiveNotices->set(accept_notices);
mCtrlReceiveNotices->setEnabled(data.mID.notNull());
mCtrlReceiveNotices->resetDirty();
@@ -225,8 +217,7 @@ BOOL LLPanelGroupGeneral::postBuild()
mCtrlReceiveChat = getChild<LLCheckBoxCtrl>("receive_chat", recurse);
if (mCtrlReceiveChat)
{
mCtrlReceiveChat->setCommitCallback(onCommitUserOnly);
mCtrlReceiveChat->setCallbackUserData(this);
mCtrlReceiveChat->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitUserOnly,this));
mCtrlReceiveChat->set(!gIMMgr->getIgnoreGroup(mGroupID));
mCtrlReceiveChat->setEnabled(mGroupID.notNull());
mCtrlReceiveChat->resetDirty();
@@ -235,8 +226,7 @@ BOOL LLPanelGroupGeneral::postBuild()
mCtrlListGroup = getChild<LLCheckBoxCtrl>("list_groups_in_profile", recurse);
if (mCtrlListGroup)
{
mCtrlListGroup->setCommitCallback(onCommitUserOnly);
mCtrlListGroup->setCallbackUserData(this);
mCtrlListGroup->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitUserOnly,this));
mCtrlListGroup->set(list_in_profile);
mCtrlListGroup->setEnabled(data.mID.notNull());
mCtrlListGroup->resetDirty();
@@ -247,8 +237,7 @@ BOOL LLPanelGroupGeneral::postBuild()
mComboActiveTitle = getChild<LLComboBox>("active_title", recurse);
if (mComboActiveTitle)
{
mComboActiveTitle->setCommitCallback(onCommitTitle);
mComboActiveTitle->setCallbackUserData(this);
mComboActiveTitle->setCommitCallback(boost::bind(&LLPanelGroupGeneral::onCommitTitle,this));
mComboActiveTitle->resetDirty();
}
@@ -283,60 +272,54 @@ void LLPanelGroupGeneral::onFocusEdit()
notifyObservers();
}
void LLPanelGroupGeneral::onCommitAny(LLUICtrl* ctrl, void* data)
void LLPanelGroupGeneral::onCommitAny()
{
LLPanelGroupGeneral* self = (LLPanelGroupGeneral*)data;
self->updateChanged();
self->notifyObservers();
updateChanged();
notifyObservers();
}
// static
void LLPanelGroupGeneral::onCommitUserOnly(LLUICtrl* ctrl, void* data)
void LLPanelGroupGeneral::onCommitUserOnly()
{
LLPanelGroupGeneral* self = (LLPanelGroupGeneral*)data;
self->mChanged = TRUE;
self->notifyObservers();
mChanged = TRUE;
notifyObservers();
}
// static
void LLPanelGroupGeneral::onCommitEnrollment(LLUICtrl* ctrl, void* data)
void LLPanelGroupGeneral::onCommitEnrollment()
{
onCommitAny(ctrl, data);
onCommitAny();
LLPanelGroupGeneral* self = (LLPanelGroupGeneral*)data;
// Make sure both enrollment related widgets are there.
if (!self->mCtrlEnrollmentFee || !self->mSpinEnrollmentFee)
if (!mCtrlEnrollmentFee || !mSpinEnrollmentFee)
{
return;
}
// Make sure the agent can change enrollment info.
if (!gAgent.hasPowerInGroup(self->mGroupID,GP_MEMBER_OPTIONS)
|| !self->mAllowEdit)
if (!gAgent.hasPowerInGroup(mGroupID,GP_MEMBER_OPTIONS)
|| !mAllowEdit)
{
return;
}
if (self->mCtrlEnrollmentFee->get())
if (mCtrlEnrollmentFee->get())
{
self->mSpinEnrollmentFee->setEnabled(TRUE);
mSpinEnrollmentFee->setEnabled(TRUE);
}
else
{
self->mSpinEnrollmentFee->setEnabled(FALSE);
self->mSpinEnrollmentFee->set(0);
mSpinEnrollmentFee->setEnabled(FALSE);
mSpinEnrollmentFee->set(0);
}
}
// static
void LLPanelGroupGeneral::onCommitTitle(LLUICtrl* ctrl, void* data)
void LLPanelGroupGeneral::onCommitTitle()
{
LLPanelGroupGeneral* self = (LLPanelGroupGeneral*)data;
if (self->mGroupID.isNull() || !self->mAllowEdit) return;
LLGroupMgr::getInstance()->sendGroupTitleUpdate(self->mGroupID,self->mComboActiveTitle->getCurrentID());
self->update(GC_TITLES);
self->mComboActiveTitle->resetDirty();
if (mGroupID.isNull() || !mAllowEdit) return;
LLGroupMgr::getInstance()->sendGroupTitleUpdate(mGroupID,mComboActiveTitle->getCurrentID());
update(GC_TITLES);
mComboActiveTitle->resetDirty();
}
// static

8
indra/newview/llpanelgroupgeneral.h
View File

@@ -68,10 +68,10 @@ public:
private:
void onFocusEdit();
static void onCommitAny(LLUICtrl* ctrl, void* data);
static void onCommitUserOnly(LLUICtrl* ctrl, void* data);
static void onCommitTitle(LLUICtrl* ctrl, void* data);
static void onCommitEnrollment(LLUICtrl* ctrl, void* data);
void onCommitAny();
void onCommitUserOnly();
void onCommitTitle();
void onCommitEnrollment();
static void onClickJoin(void* userdata);
static void onClickInfo(void* userdata);
static void onReceiveNotices(LLUICtrl* ctrl, void* data);

387
indra/newview/llpreviewgesture.cpp
View File

@@ -120,70 +120,67 @@ struct SortItemPtrsByName
// static
LLPreviewGesture* LLPreviewGesture::show(const std::string& title, const LLUUID& item_id, const LLUUID& object_id, BOOL take_focus)
{
LLPreviewGesture* previewp = (LLPreviewGesture*)LLPreview::find(item_id);
if (previewp)
LLPreviewGesture* preview = (LLPreviewGesture*)LLPreview::find(item_id);
if (preview)
{
previewp->open(); /*Flawfinder: ignore*/
if (take_focus)
}
else
{
preview = new LLPreviewGesture();
// Finish internal construction
preview->init(item_id, object_id);
// Builds and adds to gFloaterView
LLUICtrlFactory::getInstance()->buildFloater(preview, "floater_preview_gesture.xml");
preview->setTitle(title);
// Move window to top-left of screen
LLMultiFloater* hostp = preview->getHost();
if (hostp == NULL)
{
previewp->setFocus(TRUE);
LLRect r = self->getRect();
LLRect screen = gFloaterView->getRect();
r.setLeftTopAndSize(0, screen.getHeight(), r.getWidth(), r.getHeight());
preview->setRect(r);
}
else
{
// re-add to host to update title
hostp->addFloater(preview, TRUE);
}
return previewp;
}
LLPreviewGesture* self = new LLPreviewGesture();
// Start speculative download of sounds and animations
const LLUUID animation_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_ANIMATION);
LLInventoryModelBackgroundFetch::instance().start(animation_folder_id);
// Finish internal construction
self->init(item_id, object_id);
const LLUUID sound_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_SOUND);
LLInventoryModelBackgroundFetch::instance().start(sound_folder_id);
// Builds and adds to gFloaterView
LLUICtrlFactory::getInstance()->buildFloater(self, "floater_preview_gesture.xml");
self->setTitle(title);
// Move window to top-left of screen
LLMultiFloater* hostp = self->getHost();
if (hostp == NULL)
{
LLRect r = self->getRect();
LLRect screen = gFloaterView->getRect();
r.setLeftTopAndSize(0, screen.getHeight(), r.getWidth(), r.getHeight());
self->setRect(r);
}
else
{
// re-add to host to update title
hostp->addFloater(self, TRUE);
}
// Start speculative download of sounds and animations
LLUUID animation_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_ANIMATION);
LLInventoryModelBackgroundFetch::instance().start(animation_folder_id);
LLUUID sound_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_SOUND);
LLInventoryModelBackgroundFetch::instance().start(sound_folder_id);
// this will call refresh when we have everything.
LLViewerInventoryItem* item = (LLViewerInventoryItem*)self->getItem();
if (item && !item->isFinished())
{
LLInventoryGestureAvailable* observer;
observer = new LLInventoryGestureAvailable();
observer->watchItem(item_id);
gInventory.addObserver(observer);
item->fetchFromServer();
}
else
{
// not sure this is necessary.
self->refresh();
// this will call refresh when we have everything.
LLViewerInventoryItem* item = (LLViewerInventoryItem*)preview->getItem();
if (item && !item->isFinished())
{
LLInventoryGestureAvailable* observer;
observer = new LLInventoryGestureAvailable();
observer->watchItem(item_id);
gInventory.addObserver(observer);
item->fetchFromServer();
}
else
{
// not sure this is necessary.
preview->refresh();
}
}
if (take_focus)
{
self->setFocus(TRUE);
preview->setFocus(TRUE);
}
return self;
return preview;
}
void LLPreviewGesture::draw()
@@ -334,7 +331,7 @@ bool LLPreviewGesture::handleSaveChangesDialog(const LLSD& notification, const L
case 0: // "Yes"
LLGestureMgr::instance().stopGesture(mPreviewGesture);
mCloseAfterSave = TRUE;
onClickSave(this);
onClickSave();
break;
case 1: // "No"
@@ -403,9 +400,9 @@ BOOL LLPreviewGesture::postBuild()
edit = getChild<LLLineEditor>("trigger_editor");
edit->setKeystrokeCallback(onKeystrokeCommit);
edit->setCommitCallback(onCommitSetDirty);
edit->setCommitOnFocusLost(TRUE);
edit->setCallbackUserData(this);
edit->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitSetDirty,this));
edit->setCommitOnFocusLost(TRUE);
edit->setIgnoreTab(TRUE);
mTriggerEditor = edit;
@@ -416,25 +413,23 @@ BOOL LLPreviewGesture::postBuild()
edit = getChild<LLLineEditor>("replace_editor");
edit->setEnabled(FALSE);
edit->setKeystrokeCallback(onKeystrokeCommit);
edit->setCommitCallback(onCommitSetDirty);
edit->setCommitOnFocusLost(TRUE);
edit->setCallbackUserData(this);
edit->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitSetDirty,this));
edit->setCommitOnFocusLost(TRUE);
edit->setIgnoreTab(TRUE);
mReplaceEditor = edit;
combo = getChild<LLComboBox>( "modifier_combo");
combo->setCommitCallback(onCommitSetDirty);
combo->setCallbackUserData(this);
combo->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitSetDirty,this));
mModifierCombo = combo;
combo = getChild<LLComboBox>( "key_combo");
combo->setCommitCallback(onCommitSetDirty);
combo->setCallbackUserData(this);
combo->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitSetDirty,this));
mKeyCombo = combo;
list = getChild<LLScrollListCtrl>("library_list");
list->setCommitCallback(onCommitLibrary);
list->setCallbackUserData(this);
list->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitLibrary,this));
list->setDoubleClickCallback(boost::bind(&LLPreviewGesture::onClickAdd,this));
mLibraryList = list;
@@ -459,8 +454,7 @@ BOOL LLPreviewGesture::postBuild()
mDeleteBtn = btn;
list = getChild<LLScrollListCtrl>("step_list");
list->setCommitCallback(onCommitStep);
list->setCallbackUserData(this);
list->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitStep,this));
mStepList = list;
// Options
@@ -470,42 +464,38 @@ BOOL LLPreviewGesture::postBuild()
combo = getChild<LLComboBox>( "animation_list");
combo->setVisible(FALSE);
combo->setCommitCallback(onCommitAnimation);
combo->setCallbackUserData(this);
combo->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitAnimation,this));
mAnimationCombo = combo;
LLRadioGroup* group;
group = getChild<LLRadioGroup>("animation_trigger_type");
group->setVisible(FALSE);
group->setCommitCallback(onCommitAnimationTrigger);
group->setCallbackUserData(this);
group->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitAnimationTrigger,this));
mAnimationRadio = group;
combo = getChild<LLComboBox>( "sound_list");
combo->setVisible(FALSE);
combo->setCommitCallback(onCommitSound);
combo->setCallbackUserData(this);
combo->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitSound,this));
mSoundCombo = combo;
edit = getChild<LLLineEditor>("chat_editor");
edit->setVisible(FALSE);
edit->setCommitCallback(onCommitChat);
edit->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitChat,this));
//edit->setKeystrokeCallback(onKeystrokeCommit);
//edit->setCallbackUserData(this);
edit->setCommitOnFocusLost(TRUE);
edit->setCallbackUserData(this);
edit->setIgnoreTab(TRUE);
mChatEditor = edit;
check = getChild<LLCheckBoxCtrl>( "wait_anim_check");
check->setVisible(FALSE);
check->setCommitCallback(onCommitWait);
check->setCallbackUserData(this);
check->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitWait,this));
mWaitAnimCheck = check;
check = getChild<LLCheckBoxCtrl>( "wait_time_check");
check->setVisible(FALSE);
check->setCommitCallback(onCommitWait);
check->setCallbackUserData(this);
check->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitWait,this));
mWaitTimeCheck = check;
edit = getChild<LLLineEditor>("wait_time_editor");
@@ -513,16 +503,16 @@ BOOL LLPreviewGesture::postBuild()
edit->setVisible(FALSE);
edit->setPrevalidate(LLLineEditor::prevalidateFloat);
// edit->setKeystrokeCallback(onKeystrokeCommit);
//edit->setCallbackUserData(this);
edit->setCommitOnFocusLost(TRUE);
edit->setCommitCallback(onCommitWaitTime);
edit->setCallbackUserData(this);
edit->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitWaitTime,this));
edit->setIgnoreTab(TRUE);
mWaitTimeEditor = edit;
// Buttons at the bottom
check = getChild<LLCheckBoxCtrl>( "active_check");
check->setCommitCallback(onCommitActive);
check->setCallbackUserData(this);
check->setCommitCallback(boost::bind(&LLPreviewGesture::onCommitActive,this));
mActiveCheck = check;
btn = getChild<LLButton>( "save_btn");
@@ -1403,47 +1393,35 @@ void LLPreviewGesture::updateLabel(LLScrollListItem* item)
text_cell->setText(label);
}
// static
void LLPreviewGesture::onCommitSetDirty(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitSetDirty()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
self->mDirty = TRUE;
self->refresh();
mDirty = TRUE;
refresh();
}
// static
void LLPreviewGesture::onCommitLibrary(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitLibrary()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* library_item = self->mLibraryList->getFirstSelected();
LLScrollListItem* library_item = mLibraryList->getFirstSelected();
if (library_item)
{
self->mStepList->deselectAllItems();
self->refresh();
mStepList->deselectAllItems();
refresh();
}
}
// static
void LLPreviewGesture::onCommitStep(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitStep()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* step_item = self->mStepList->getFirstSelected();
LLScrollListItem* step_item = mStepList->getFirstSelected();
if (!step_item) return;
self->mLibraryList->deselectAllItems();
self->refresh();
mLibraryList->deselectAllItems();
refresh();
}
// static
void LLPreviewGesture::onCommitAnimation(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitAnimation()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* step_item = self->mStepList->getFirstSelected();
LLScrollListItem* step_item = mStepList->getFirstSelected();
if (step_item)
{
LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
@@ -1451,40 +1429,37 @@ void LLPreviewGesture::onCommitAnimation(LLUICtrl* ctrl, void* data)
{
// Assign the animation name
LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
if (self->mAnimationCombo->getCurrentIndex() == 0)
if (mAnimationCombo->getCurrentIndex() == 0)
{
anim_step->mAnimName.clear();
anim_step->mAnimAssetID.setNull();
}
else
{
anim_step->mAnimName = self->mAnimationCombo->getSimple();
anim_step->mAnimAssetID = self->mAnimationCombo->getCurrentID();
anim_step->mAnimName = mAnimationCombo->getSimple();
anim_step->mAnimAssetID = mAnimationCombo->getCurrentID();
}
//anim_step->mFlags = 0x0;
// Update the UI label in the list
updateLabel(step_item);
self->mDirty = TRUE;
self->refresh();
mDirty = TRUE;
refresh();
}
}
}
// static
void LLPreviewGesture::onCommitAnimationTrigger(LLUICtrl* ctrl, void *data)
void LLPreviewGesture::onCommitAnimationTrigger()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* step_item = self->mStepList->getFirstSelected();
LLScrollListItem* step_item = mStepList->getFirstSelected();
if (step_item)
{
LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
if (step->getType() == STEP_ANIMATION)
{
LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
if (self->mAnimationRadio->getSelectedIndex() == 0)
if (mAnimationRadio->getSelectedIndex() == 0)
{
// start
anim_step->mFlags &= ~ANIM_FLAG_STOP;
@@ -1497,18 +1472,15 @@ void LLPreviewGesture::onCommitAnimationTrigger(LLUICtrl* ctrl, void *data)
// Update the UI label in the list
updateLabel(step_item);
self->mDirty = TRUE;
self->refresh();
mDirty = TRUE;
refresh();
}
}
}
// static
void LLPreviewGesture::onCommitSound(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitSound()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* step_item = self->mStepList->getFirstSelected();
LLScrollListItem* step_item = mStepList->getFirstSelected();
if (step_item)
{
LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
@@ -1516,90 +1488,81 @@ void LLPreviewGesture::onCommitSound(LLUICtrl* ctrl, void* data)
{
// Assign the sound name
LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
sound_step->mSoundName = self->mSoundCombo->getSimple();
sound_step->mSoundAssetID = self->mSoundCombo->getCurrentID();
sound_step->mSoundName = mSoundCombo->getSimple();
sound_step->mSoundAssetID = mSoundCombo->getCurrentID();
sound_step->mFlags = 0x0;
// Update the UI label in the list
updateLabel(step_item);
self->mDirty = TRUE;
self->refresh();
mDirty = TRUE;
refresh();
}
}
}
// static
void LLPreviewGesture::onCommitChat(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitChat()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* step_item = self->mStepList->getFirstSelected();
LLScrollListItem* step_item = mStepList->getFirstSelected();
if (!step_item) return;
LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
if (step->getType() != STEP_CHAT) return;
LLGestureStepChat* chat_step = (LLGestureStepChat*)step;
chat_step->mChatText = self->mChatEditor->getText();
chat_step->mChatText = mChatEditor->getText();
chat_step->mFlags = 0x0;
// Update the UI label in the list
updateLabel(step_item);
self->mDirty = TRUE;
self->refresh();
mDirty = TRUE;
refresh();
}
// static
void LLPreviewGesture::onCommitWait(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitWait()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* step_item = self->mStepList->getFirstSelected();
LLScrollListItem* step_item = mStepList->getFirstSelected();
if (!step_item) return;
LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
if (step->getType() != STEP_WAIT) return;
if (getType() != STEP_WAIT) return;
LLGestureStepWait* wait_step = (LLGestureStepWait*)step;
U32 flags = 0x0;
if (self->mWaitAnimCheck->get()) flags |= WAIT_FLAG_ALL_ANIM;
if (self->mWaitTimeCheck->get()) flags |= WAIT_FLAG_TIME;
if (mWaitAnimCheck->get()) flags |= WAIT_FLAG_ALL_ANIM;
if (mWaitTimeCheck->get()) flags |= WAIT_FLAG_TIME;
wait_step->mFlags = flags;
{
LLLocale locale(LLLocale::USER_LOCALE);
F32 wait_seconds = (F32)atof(self->mWaitTimeEditor->getText().c_str());
F32 wait_seconds = (F32)atof(mWaitTimeEditor->getText().c_str());
if (wait_seconds < 0.f) wait_seconds = 0.f;
if (wait_seconds > 3600.f) wait_seconds = 3600.f;
wait_step->mWaitSeconds = wait_seconds;
}
// Enable the input area if necessary
self->mWaitTimeEditor->setEnabled(self->mWaitTimeCheck->get());
mWaitTimeEditor->setEnabled(mWaitTimeCheck->get());
// Update the UI label in the list
updateLabel(step_item);
self->mDirty = TRUE;
self->refresh();
mDirty = TRUE;
refresh();
}
// static
void LLPreviewGesture::onCommitWaitTime(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitWaitTime()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* step_item = self->mStepList->getFirstSelected();
LLScrollListItem* step_item = mStepList->getFirstSelected();
if (!step_item) return;
LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
if (step->getType() != STEP_WAIT) return;
self->mWaitTimeCheck->set(TRUE);
onCommitWait(ctrl, data);
mWaitTimeCheck->set(TRUE);
onCommitWait();
}
@@ -1608,18 +1571,15 @@ void LLPreviewGesture::onKeystrokeCommit(LLLineEditor* caller,
void* data)
{
// Just commit every keystroke
onCommitSetDirty(caller, data);
((LLPreviewGesture*)data)->onCommitSetDirty();
}
// static
void LLPreviewGesture::onClickAdd(void* data)
void LLPreviewGesture::onClickAdd()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* library_item = self->mLibraryList->getFirstSelected();
LLScrollListItem* library_item = mLibraryList->getFirstSelected();
if (!library_item) return;
S32 library_item_index = self->mLibraryList->getFirstSelectedIndex();
S32 library_item_index = mLibraryList->getFirstSelectedIndex();
const LLScrollListCell* library_cell = library_item->getColumn(0);
const std::string& library_text = library_cell->getValue().asString();
@@ -1630,9 +1590,9 @@ void LLPreviewGesture::onClickAdd(void* data)
return;
}
self->addStep( (EStepType)library_item_index );
self->mDirty = TRUE;
self->refresh();
addStep( (EStepType)library_item_index );
mDirty = TRUE;
refresh();
}
LLScrollListItem* LLPreviewGesture::addStep( const EStepType step_type )
@@ -1732,129 +1692,110 @@ std::string LLPreviewGesture::getLabel(std::vector<std::string> labels)
return result;
}
// static
void LLPreviewGesture::onClickUp(void* data)
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
S32 selected_index = self->mStepList->getFirstSelectedIndex();
void LLPreviewGesture::onClickUp()
{
S32 selected_index = mStepList->getFirstSelectedIndex();
if (selected_index > 0)
{
self->mStepList->swapWithPrevious(selected_index);
self->mDirty = TRUE;
self->refresh();
mStepList->swapWithPrevious(selected_index);
mDirty = TRUE;
refresh();
}
}
// static
void LLPreviewGesture::onClickDown(void* data)
void LLPreviewGesture::onClickDown()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
S32 selected_index = self->mStepList->getFirstSelectedIndex();
S32 selected_index = mStepList->getFirstSelectedIndex();
if (selected_index < 0) return;
S32 count = self->mStepList->getItemCount();
S32 count = mStepList->getItemCount();
if (selected_index < count-1)
{
self->mStepList->swapWithNext(selected_index);
self->mDirty = TRUE;
self->refresh();
mStepList->swapWithNext(selected_index);
mDirty = TRUE;
refresh();
}
}
// static
void LLPreviewGesture::onClickDelete(void* data)
void LLPreviewGesture::onClickDelete()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
LLScrollListItem* item = self->mStepList->getFirstSelected();
S32 selected_index = self->mStepList->getFirstSelectedIndex();
LLScrollListItem* item = mStepList->getFirstSelected();
S32 selected_index = mStepList->getFirstSelectedIndex();
if (item && selected_index >= 0)
{
LLGestureStep* step = (LLGestureStep*)item->getUserdata();
delete step;
step = NULL;
self->mStepList->deleteSingleItem(selected_index);
mStepList->deleteSingleItem(selected_index);
self->mDirty = TRUE;
self->refresh();
mDirty = TRUE;
refresh();
}
}
// static
void LLPreviewGesture::onCommitActive(LLUICtrl* ctrl, void* data)
void LLPreviewGesture::onCommitActive()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
if (!LLGestureMgr::instance().isGestureActive(self->mItemUUID))
if (!LLGestureMgr::instance().isGestureActive(mItemUUID))
{
LLGestureMgr::instance().activateGesture(self->mItemUUID);
LLGestureMgr::instance().activateGesture(mItemUUID);
}
else
{
LLGestureMgr::instance().deactivateGesture(self->mItemUUID);
LLGestureMgr::instance().deactivateGesture(mItemUUID);
}
// Make sure the (active) label in the inventory gets updated.
LLViewerInventoryItem* item = gInventory.getItem(self->mItemUUID);
LLViewerInventoryItem* item = gInventory.getItem(mItemUUID);
if (item)
{
gInventory.updateItem(item);
gInventory.notifyObservers();
}
self->refresh();
refresh();
}
// static
void LLPreviewGesture::onClickSave(void* data)
void LLPreviewGesture::onClickSave()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
self->saveIfNeeded();
saveIfNeeded();
}
// static
void LLPreviewGesture::onClickPreview(void* data)
void LLPreviewGesture::onClickPreview()
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
if (!self->mPreviewGesture)
if (!mPreviewGesture)
{
// make temporary gesture
self->mPreviewGesture = self->createGesture();
mPreviewGesture = createGesture();
// add a callback
self->mPreviewGesture->mDoneCallback = onDonePreview;
self->mPreviewGesture->mCallbackData = self;
mPreviewGesture->mDoneCallback = boost::bind(&LLPreviewGesture::onDonePreview,this,_1);
// set the button title
self->mPreviewBtn->setLabel(self->getString("stop_txt"));
mPreviewBtn->setLabel(getString("stop_txt"));
// play it, and delete when done
LLGestureMgr::instance().playGesture(self->mPreviewGesture);
LLGestureMgr::instance().playGesture(mPreviewGesture);
self->refresh();
refresh();
}
else
{
// Will call onDonePreview() below
LLGestureMgr::instance().stopGesture(self->mPreviewGesture);
LLGestureMgr::instance().stopGesture(mPreviewGesture);
self->refresh();
refresh();
}
}
// static
void LLPreviewGesture::onDonePreview(LLMultiGesture* gesture, void* data)
void LLPreviewGesture::onDonePreview(LLMultiGesture* gesture)
{
LLPreviewGesture* self = (LLPreviewGesture*)data;
mPreviewBtn->setLabel(getString("preview_txt"));
self->mPreviewBtn->setLabel(self->getString("preview_txt"));
delete mPreviewGesture;
mPreviewGesture = NULL;
delete self->mPreviewGesture;
self->mPreviewGesture = NULL;
self->refresh();
refresh();
}

34
indra/newview/llpreviewgesture.h
View File

@@ -116,30 +116,30 @@ protected:
static std::string getLabel(std::vector<std::string> labels);
static void updateLabel(LLScrollListItem* item);
static void onCommitSetDirty(LLUICtrl* ctrl, void* data);
static void onCommitLibrary(LLUICtrl* ctrl, void* data);
static void onCommitStep(LLUICtrl* ctrl, void* data);
static void onCommitAnimation(LLUICtrl* ctrl, void* data);
static void onCommitSound(LLUICtrl* ctrl, void* data);
static void onCommitChat(LLUICtrl* ctrl, void* data);
static void onCommitWait(LLUICtrl* ctrl, void* data);
static void onCommitWaitTime(LLUICtrl* ctrl, void* data);
void onCommitSetDirty();
void onCommitLibrary();
void onCommitStep();
void onCommitAnimation();
void onCommitSound();
void onCommitChat();
void onCommitWait();
void onCommitWaitTime();
static void onCommitAnimationTrigger(LLUICtrl* ctrl, void *data);
void onCommitAnimationTrigger();
// Handy function to commit each keystroke
static void onKeystrokeCommit(LLLineEditor* caller, void* data);
static void onClickAdd(void* data);
static void onClickUp(void* data);
static void onClickDown(void* data);
static void onClickDelete(void* data);
void onClickAdd();
void onClickUp();
void onClickDown();
void onClickDelete();
static void onCommitActive(LLUICtrl* ctrl, void* data);
static void onClickSave(void* data);
static void onClickPreview(void* data);
void onCommitActive();
void onClickSave();
void onClickPreview();
static void onDonePreview(LLMultiGesture* gesture, void* data);
void onDonePreview(LLMultiGesture* gesture);
virtual const char *getTitleName() const { return "Gesture"; }