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(), mSteps(),
mPlaying(FALSE), mPlaying(FALSE),
mCurrentStep(0), mCurrentStep(0),
mDoneCallback(NULL), mDoneCallback(NULL)
mCallbackData(NULL)
{ {
reset(); reset();
} }

3
indra/llcharacter/llmultigesture.h
View File

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

48
indra/newview/floaterao.cpp
View File

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

8
indra/newview/floaterao.h
View File

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

27
indra/newview/floaterlocalassetbrowse.cpp
View File

@@ -800,13 +800,13 @@ FloaterLocalAssetBrowser::FloaterLocalAssetBrowser()
mUploadBtn->setClickedCallback( onClickUpload, this); mUploadBtn->setClickedCallback( onClickUpload, this);
// combo callback // combo callback
mTypeComboBox->setCommitCallback(onCommitTypeCombo); mTypeComboBox->setCommitCallback(boost::bind(&FloaterLocalAssetBrowser::onCommitTypeCombo,this));
// scrolllist callbacks // scrolllist callbacks
mBitmapList->setCommitCallback(onChooseBitmapList); mBitmapList->setCommitCallback(boost::bind(&FloaterLocalAssetBrowser::onChooseBitmapList,this));
// checkbox callbacks // 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(); bool button_status = mBitmapList->isEmpty();
sLFInstance->mDelBtn->setEnabled(!button_status); mDelBtn->setEnabled(!button_status);
sLFInstance->mUploadBtn->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() ) if ( !temp_str.empty() )
{ {
gLocalBrowser->onUpdateBool( (LLUUID)temp_str ); 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() ) if ( !temp_str.empty() )
{ {
S32 selection = sLFInstance->mTypeComboBox->getCurrentIndex(); S32 selection = sLFInstance->mTypeComboBox->getCurrentIndex();
gLocalBrowser->onSetType( (LLUUID)temp_str, selection ); gLocalBrowser->onSetType( (LLUUID)temp_str, selection );
} }
} }

6
indra/newview/floaterlocalassetbrowse.h
View File

@@ -236,13 +236,13 @@ private:
static void onClickUpload(void* userdata); static void onClickUpload(void* userdata);
// ScrollList callback declarations // ScrollList callback declarations
static void onChooseBitmapList(LLUICtrl* ctrl, void* userdata); void onChooseBitmapList();
// Checkbox callback declarations // Checkbox callback declarations
static void onClickUpdateChkbox(LLUICtrl* ctrl, void* userdata); void onClickUpdateChkbox();
// Combobox type select // Combobox type select
static void onCommitTypeCombo(LLUICtrl* ctrl, void* userdata); void onCommitTypeCombo();
// Widgets // Widgets
LLButton* mAddBtn; 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->setValue(*var);
} }
box->mSlider1->setCommitCallback(slider_changed); box->mSlider1->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider1->setCallbackUserData(box); box->mSlider1->setCallbackUserData(box);
#endif #endif
} }
@@ -129,8 +129,7 @@ void LLDebugVarMessageBox::show(const std::string& title, S32 *var, S32 max_valu
{ {
box->mSlider1->setValue((F32)*var); box->mSlider1->setValue((F32)*var);
} }
box->mSlider1->setCommitCallback(slider_changed); box->mSlider1->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider1->setCallbackUserData(box);
#endif #endif
} }
@@ -142,20 +141,17 @@ void LLDebugVarMessageBox::show(const std::string& title, LLVector3 *var, LLVect
box->mSlider1->setMaxValue(max_value.mV[VX]); box->mSlider1->setMaxValue(max_value.mV[VX]);
box->mSlider1->setMinValue(-max_value.mV[VX]); box->mSlider1->setMinValue(-max_value.mV[VX]);
box->mSlider1->setIncrement(increment.mV[VX]); box->mSlider1->setIncrement(increment.mV[VX]);
box->mSlider1->setCommitCallback(slider_changed); box->mSlider1->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider1->setCallbackUserData(box);
box->mSlider2->setMaxValue(max_value.mV[VX]); box->mSlider2->setMaxValue(max_value.mV[VX]);
box->mSlider2->setMinValue(-max_value.mV[VX]); box->mSlider2->setMinValue(-max_value.mV[VX]);
box->mSlider2->setIncrement(increment.mV[VX]); box->mSlider2->setIncrement(increment.mV[VX]);
box->mSlider2->setCommitCallback(slider_changed); box->mSlider2->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider2->setCallbackUserData(box);
box->mSlider3->setMaxValue(max_value.mV[VX]); box->mSlider3->setMaxValue(max_value.mV[VX]);
box->mSlider3->setMinValue(-max_value.mV[VX]); box->mSlider3->setMinValue(-max_value.mV[VX]);
box->mSlider3->setIncrement(increment.mV[VX]); box->mSlider3->setIncrement(increment.mV[VX]);
box->mSlider3->setCommitCallback(slider_changed); box->mSlider3->setCommitCallback(boost::bind(&LLDebugVarMessageBox::slider_changed,_1,box));
box->mSlider3->setCallbackUserData(box);
#endif #endif
} }

10
indra/newview/llfloateractivespeakers.cpp
View File

@@ -335,7 +335,7 @@ BOOL LLPanelActiveSpeakers::postBuild()
mSpeakerList->sortByColumn(sort_column, sort_ascending); mSpeakerList->sortByColumn(sort_column, sort_ascending);
mSpeakerList->setDoubleClickCallback(boost::bind(&onDoubleClickSpeaker,this)); mSpeakerList->setDoubleClickCallback(boost::bind(&onDoubleClickSpeaker,this));
mSpeakerList->setCommitOnSelectionChange(TRUE); mSpeakerList->setCommitOnSelectionChange(TRUE);
mSpeakerList->setCommitCallback(onSelectSpeaker); mSpeakerList->setCommitCallback(boost::bind(&LLPanelActiveSpeakers::handleSpeakerSelect,this));
mSpeakerList->setSortChangedCallback(boost::bind(&LLPanelActiveSpeakers::onSortChanged,this)); mSpeakerList->setSortChangedCallback(boost::bind(&LLPanelActiveSpeakers::onSortChanged,this));
mSpeakerList->setCallbackUserData(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 //static
void LLPanelActiveSpeakers::onSortChanged(void* user_data) 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 onVolumeChange(LLUICtrl* source, void* user_data);
static void onClickProfile(void* user_data); static void onClickProfile(void* user_data);
static void onDoubleClickSpeaker(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 onSortChanged(void* user_data);
static void onModeratorMuteVoice(LLUICtrl* ctrl, void* user_data); static void onModeratorMuteVoice(LLUICtrl* ctrl, void* user_data);
static void onModeratorMuteText(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->sortByColumn("distance", TRUE);
mAvatarList->setCommitOnSelectionChange(TRUE); mAvatarList->setCommitOnSelectionChange(TRUE);
mAvatarList->setCallbackUserData(this); mAvatarList->setCallbackUserData(this);
mAvatarList->setCommitCallback(onSelectName); mAvatarList->setCommitCallback(boost::bind(&LLFloaterAvatarList::onSelectName,this));
mAvatarList->setDoubleClickCallback(boost::bind(&LLFloaterAvatarList::onClickFocus,this)); mAvatarList->setDoubleClickCallback(boost::bind(&LLFloaterAvatarList::onClickFocus,this));
refreshAvatarList(); 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 = mAvatarList->getFirstSelected();
LLScrollListItem* item = self->mAvatarList->getFirstSelected();
if (item) if (item)
{ {
LLUUID agent_id = item->getUUID(); LLUUID agent_id = item->getUUID();
LLAvatarListEntry* entry = self->getAvatarEntry(agent_id); LLAvatarListEntry* entry = getAvatarEntry(agent_id);
if (entry) if (entry)
{ {
BOOL enabled = entry->isDrawn(); BOOL enabled = entry->isDrawn();
self->childSetEnabled("focus_btn", enabled); childSetEnabled("focus_btn", enabled);
self->childSetEnabled("prev_in_list_btn", enabled); childSetEnabled("prev_in_list_btn", enabled);
self->childSetEnabled("next_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 callbackEjectFromEstate(const LLSD& notification, const LLSD& response);
static void callbackBanFromEstate(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 onCommitUpdateRate(LLUICtrl*, void *userdata);
static void onClickSendKeys(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 = getChild<LLCheckBoxCtrl>("apply_immediate");
mApplyImmediateCheck->set(gSavedSettings.getBOOL("ApplyColorImmediately")); mApplyImmediateCheck->set(gSavedSettings.getBOOL("ApplyColorImmediately"));
mApplyImmediateCheck->setCommitCallback(onImmediateCheck); mApplyImmediateCheck->setCommitCallback(boost::bind(&LLFloaterColorPicker::onImmediateCheck,this));
mApplyImmediateCheck->setCallbackUserData(this);
childSetCommitCallback("rspin", onTextCommit, (void*)this ); childSetCommitCallback("rspin", onTextCommit, (void*)this );
childSetCommitCallback("gspin", 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; gSavedSettings.setBOOL("ApplyColorImmediately", mApplyImmediateCheck->get());
if (self)
{
gSavedSettings.setBOOL("ApplyColorImmediately", self->mApplyImmediateCheck->get());
if (self->mApplyImmediateCheck->get()) if (mApplyImmediateCheck->get())
{ {
LLColorSwatchCtrl::onColorChanged ( self->getSwatch (), LLColorSwatchCtrl::COLOR_CHANGE ); 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 onClickPipette ( void* data );
static void onTextCommit ( LLUICtrl* ctrl, void* data ); static void onTextCommit ( LLUICtrl* ctrl, void* data );
static void onHexCommit ( 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 ); static void onColorSelect( const LLTextureEntry& te, void *data );
private: private:
// turns on or off text entry commit call backs // 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("DayCycleSavePreset", onSavePreset, comboBox);
childSetAction("DayCycleDeletePreset", onDeletePreset, comboBox); childSetAction("DayCycleDeletePreset", onDeletePreset, comboBox);
comboBox->setCommitCallback(onChangePresetName); comboBox->setCommitCallback(boost::bind(&LLFloaterDayCycle::onChangePresetName,_1));
childSetAction("WLAddKey", onAddKey, NULL); 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); 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); static bool newPromptCallback(const LLSD& notification, const LLSD& response);
/// what to do when you change the preset name /// 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 /// toggle for Linden time
static void onUseLindenTime(void* userData); 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 = getChild<LLScrollListCtrl>("friend_list");
mFriendsList->setCommitOnSelectionChange(TRUE); mFriendsList->setCommitOnSelectionChange(TRUE);
childSetCommitCallback("friend_list", onSelectName, this); mFriendsList->setCommitCallback(onSelectName, this);
childSetCommitCallback("buddy_group_combobox", onChangeContactGroup, this); childSetCommitCallback("buddy_group_combobox", onChangeContactGroup, this);
mFriendsList->setDoubleClickCallback(onClickIM, this); mFriendsList->setDoubleClickCallback(onClickIM, this);

21
indra/newview/llfloatergesture.cpp
View File

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

2
indra/newview/llfloatergesture.h
View File

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

38
indra/newview/llfloatergroups.cpp
View File

@@ -70,9 +70,6 @@ std::map<const LLUUID, LLFloaterGroupPicker*> LLFloaterGroupPicker::sInstances;
// helper functions // helper functions
void init_group_list(LLScrollListCtrl* ctrl, const LLUUID& highlight_id, const std::string& none_text, U64 powers_mask = GP_ALL_POWERS); 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 /// Class LLFloaterGroupPicker
///---------------------------------------------------------------------------- ///----------------------------------------------------------------------------
@@ -128,7 +125,8 @@ BOOL LLFloaterGroupPicker::postBuild()
{ {
const std::string none_text = getString("none"); 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); childSetAction("OK", onBtnOK, this);
@@ -213,15 +211,14 @@ void LLPanelGroups::reset()
BOOL LLPanelGroups::postBuild() BOOL LLPanelGroups::postBuild()
{ {
childSetCommitCallback("group list", onGroupList, this);
childSetTextArg("groupcount", "[COUNT]", llformat("%d",gAgent.mGroups.count())); childSetTextArg("groupcount", "[COUNT]", llformat("%d",gAgent.mGroups.count()));
childSetTextArg("groupcount", "[MAX]", llformat("%d", gHippoLimits->getMaxAgentGroups())); childSetTextArg("groupcount", "[MAX]", llformat("%d", gHippoLimits->getMaxAgentGroups()));
const std::string none_text = getString("none"); const std::string none_text = getString("none");
LLScrollListCtrl *group_list = getChild<LLScrollListCtrl>("group list"); LLScrollListCtrl *group_list = getChild<LLScrollListCtrl>("group list");
init_group_list(group_list, gAgent.getGroupID(), none_text); 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)); group_list->setDoubleClickCallback(boost::bind(&LLPanelGroups::onBtnIM,this));
childSetAction("Activate", onBtnActivate, this); childSetAction("Activate", onBtnActivate, this);
@@ -475,15 +472,20 @@ bool LLPanelGroups::callbackLeaveGroup(const LLSD& notification, const LLSD& res
return false; return false;
} }
void LLPanelGroups::onGroupList(LLUICtrl* ctrl, void* userdata) void LLPanelGroups::onGroupSortChanged()
{ {
LLPanelGroups *self = (LLPanelGroups*)userdata; LLScrollListCtrl *group_list = getChild<LLScrollListCtrl>("group list");
if(!self) if(!group_list)
return; 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) if(!group_list)
return; return;
@@ -558,18 +560,6 @@ LLSD create_group_element(const LLGroupData *group_datap, const LLUUID &active_g
return element; 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) void init_group_list(LLScrollListCtrl* ctrl, const LLUUID& highlight_id, const std::string& none_text, U64 powers_mask)
{ {
S32 count = gAgent.mGroups.count(); 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 // highlight_id is a group id to highlight
void enableButtons(); void enableButtons();
static void onGroupList(LLUICtrl* ctrl, void* userdata); void onGroupSortChanged();
void onGroupList();
static void onBtnCreate(void* userdata); static void onBtnCreate(void* userdata);
static void onBtnActivate(void* userdata); static void onBtnActivate(void* userdata);
static void onBtnInfo(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 = getChild<LLNameListCtrl>("owner list");
mOwnerList->sortByColumnIndex(3, FALSE); mOwnerList->sortByColumnIndex(3, FALSE);
childSetCommitCallback("owner list", onCommitList, this); mOwnerList->setCommitCallback(boost::bind(&LLPanelLandObjects::onCommitList,this));
mOwnerList->setDoubleClickCallback(boost::bind(&LLPanelLandObjects::onDoubleClickOwner, this)); mOwnerList->setDoubleClickCallback(boost::bind(&LLPanelLandObjects::onDoubleClickOwner, this));
return TRUE; return TRUE;
@@ -1621,16 +1621,13 @@ void LLPanelLandObjects::processParcelObjectOwnersReply(LLMessageSystem *msg, vo
} }
} }
// static void LLPanelLandObjects::onCommitList()
void LLPanelLandObjects::onCommitList(LLUICtrl* ctrl, void* data)
{ {
LLPanelLandObjects* self = (LLPanelLandObjects*)data; if (FALSE == mOwnerList->getCanSelect())
if (FALSE == self->mOwnerList->getCanSelect())
{ {
return; return;
} }
LLScrollListItem *item = self->mOwnerList->getFirstSelected(); LLScrollListItem *item = mOwnerList->getFirstSelected();
if (item) if (item)
{ {
// Look up the selected name, for future dialog box use. // Look up the selected name, for future dialog box use.
@@ -1641,19 +1638,19 @@ void LLPanelLandObjects::onCommitList(LLUICtrl* ctrl, void* data)
return; return;
} }
// Is this a group? // Is this a group?
self->mSelectedIsGroup = cell->getValue().asString() == OWNER_GROUP; mSelectedIsGroup = cell->getValue().asString() == OWNER_GROUP;
cell = item->getColumn(2); cell = item->getColumn(2);
self->mSelectedName = cell->getValue().asString(); mSelectedName = cell->getValue().asString();
cell = item->getColumn(3); 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. // Set the selection, and enable the return button.
self->mSelectedOwners.clear(); mSelectedOwners.clear();
self->mSelectedOwners.insert(item->getUUID()); mSelectedOwners.insert(item->getUUID());
self->mBtnReturnOwnerList->setEnabled(TRUE); mBtnReturnOwnerList->setEnabled(TRUE);
// Highlight this user's objects // 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 onDoubleClickOwner(void*);
static void onCommitList(LLUICtrl* ctrl, void* data); void onCommitList();
static void onLostFocus(LLFocusableElement* caller, void* user_data); static void onLostFocus(LLFocusableElement* caller, void* user_data);
static void onCommitClean(LLUICtrl* caller, void* user_data); static void onCommitClean(LLUICtrl* caller, void* user_data);
static void processParcelObjectOwnersReply(LLMessageSystem *msg, void **); 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"); LLScrollListCtrl* results = getChild<LLScrollListCtrl>("results");
if (results) if (results)
{ {
results->setSortChangedCallback(onClickSort); results->setSortChangedCallback(boost::bind(&LLPanelDirLand::onClickSort,this));
results->sortByColumn(mCurrentSortColumn,mCurrentSortAscending); results->sortByColumn(mCurrentSortColumn,mCurrentSortAscending);
LLStringUtil::format_map_t args; LLStringUtil::format_map_t args;

79
indra/newview/llpanelgroupgeneral.cpp
View File

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

8
indra/newview/llpanelgroupgeneral.h
View File

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

387
indra/newview/llpreviewgesture.cpp
View File

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

34
indra/newview/llpreviewgesture.h
View File

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