开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llpreviewgesture.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：44k
源码类别：

游戏引擎

开发平台：

C++ Builder

llpreviewgesture.cpp：源码内容
  1. /** 
  2.  * @file llpreviewgesture.cpp
  3.  * @brief Editing UI for inventory-based gestures.
  4.  *
  5.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2004-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llpreviewgesture.h"
  37. #include <algorithm>
  39. // libraries
  40. #include "lldatapacker.h"
  41. #include "lldarray.h"
  42. #include "llstring.h"
  43. #include "lldir.h"
  44. #include "llfloaterreg.h"
  45. #include "llmultigesture.h"
  46. #include "llnotificationsutil.h"
  47. #include "llvfile.h"
  49. // newview
  50. #include "llagent.h" // todo: remove
  51. #include "llanimationstates.h"
  52. #include "llassetuploadresponders.h"
  53. #include "llbutton.h"
  54. #include "llcheckboxctrl.h"
  55. #include "llcombobox.h"
  56. #include "lldelayedgestureerror.h"
  57. #include "llfloatergesture.h" // for some label constants
  58. #include "llgesturemgr.h"
  59. #include "llinventorymodel.h"
  60. #include "llkeyboard.h"
  61. #include "lllineeditor.h"
  62. #include "llradiogroup.h"
  63. #include "llscrolllistctrl.h"
  64. #include "llscrolllistitem.h"
  65. #include "llscrolllistcell.h"
  66. #include "lltextbox.h"
  67. #include "lluictrlfactory.h"
  68. #include "llviewerinventory.h"
  69. #include "llviewerobject.h"
  70. #include "llviewerobjectlist.h"
  71. #include "llviewerregion.h"
  72. #include "llviewerstats.h"
  73. #include "llviewerwindow.h" // busycount
  74. #include "llvoavatarself.h"
  75. #include "llappviewer.h" // gVFS
  76. #include "llanimstatelabels.h"
  77. #include "llresmgr.h"
  78. #include "lltrans.h"
  81. std::string NONE_LABEL;
  82. std::string SHIFT_LABEL;
  83. std::string CTRL_LABEL;
  85. void dialog_refresh_all();
  87. // used for getting
  89. class LLInventoryGestureAvailable : public LLInventoryCompletionObserver
  90. {
  91. public:
  92. LLInventoryGestureAvailable() {}
  94. protected:
  95. virtual void done();
  96. };
  98. void LLInventoryGestureAvailable::done()
  99. {
  100. for(item_ref_t::iterator it = mComplete.begin(); it != mComplete.end(); ++it)
  101. {
  102. LLPreviewGesture* preview = LLFloaterReg::findTypedInstance<LLPreviewGesture>("preview_gesture", *it);
  103. if(preview)
  104. {
  105. preview->refresh();
  106. }
  107. }
  108. gInventory.removeObserver(this);
  109. delete this;
  110. }
  112. // Used for sorting
  113. struct SortItemPtrsByName
  114. {
  115. bool operator()(const LLInventoryItem* i1, const LLInventoryItem* i2)
  116. {
  117. return (LLStringUtil::compareDict(i1->getName(), i2->getName()) < 0);
  118. }
  119. };
  121. // static
  122. LLPreviewGesture* LLPreviewGesture::show(const LLUUID& item_id, const LLUUID& object_id)
  123. {
  124. LLPreviewGesture* preview = LLFloaterReg::showTypedInstance<LLPreviewGesture>("preview_gesture", LLSD(item_id), TAKE_FOCUS_YES);
  125. if (!preview)
  126. {
  127. return NULL;
  128. }
  130. preview->setObjectID(object_id);
  132. // Start speculative download of sounds and animations
  133. const LLUUID animation_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_ANIMATION);
  134. gInventory.startBackgroundFetch(animation_folder_id);
  136. const LLUUID sound_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_SOUND);
  137. gInventory.startBackgroundFetch(sound_folder_id);
  139. // this will call refresh when we have everything.
  140. LLViewerInventoryItem* item = (LLViewerInventoryItem*)preview->getItem();
  141. if (item && !item->isComplete())
  142. {
  143. LLInventoryGestureAvailable* observer;
  144. observer = new LLInventoryGestureAvailable();
  145. observer->watchItem(item_id);
  146. gInventory.addObserver(observer);
  147. item->fetchFromServer();
  148. }
  149. else
  150. {
  151. // not sure this is necessary.
  152. preview->refresh();
  153. }
  155. return preview;
  156. }
  158. void LLPreviewGesture::draw()
  159. {
  160. // Skip LLPreview::draw() to avoid description update
  161. LLFloater::draw();
  162. }
  164. // virtual
  165. BOOL LLPreviewGesture::handleKeyHere(KEY key, MASK mask)
  166. {
  167. if(('S' == key) && (MASK_CONTROL == (mask & MASK_CONTROL)))
  168. {
  169. saveIfNeeded();
  170. return TRUE;
  171. }
  173. return LLPreview::handleKeyHere(key, mask);
  174. }
  177. // virtual
  178. BOOL LLPreviewGesture::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  179.  EDragAndDropType cargo_type,
  180.  void* cargo_data,
  181.  EAcceptance* accept,
  182.  std::string& tooltip_msg)
  183. {
  184. BOOL handled = TRUE;
  185. switch(cargo_type)
  186. {
  187. case DAD_ANIMATION:
  188. case DAD_SOUND:
  189. {
  190. // TODO: Don't allow this if you can't transfer the sound/animation
  192. // make a script step
  193. LLInventoryItem* item = (LLInventoryItem*)cargo_data;
  194. if (item
  195. && gInventory.getItem(item->getUUID()))
  196. {
  197. LLPermissions perm = item->getPermissions();
  198. if (!((perm.getMaskBase() & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED))
  199. {
  200. *accept = ACCEPT_NO;
  201. if (tooltip_msg.empty())
  202. {
  203. tooltip_msg.assign("Only animations and soundsn"
  204. "with unrestricted permissionsn"
  205. "can be added to a gesture.");
  206. }
  207. break;
  208. }
  209. else if (drop)
  210. {
  211. LLScrollListItem* line = NULL;
  212. if (cargo_type == DAD_ANIMATION)
  213. {
  214. line = addStep( STEP_ANIMATION );
  215. LLGestureStepAnimation* anim = (LLGestureStepAnimation*)line->getUserdata();
  216. anim->mAnimAssetID = item->getAssetUUID();
  217. anim->mAnimName = item->getName();
  218. }
  219. else if (cargo_type == DAD_SOUND)
  220. {
  221. line = addStep( STEP_SOUND );
  222. LLGestureStepSound* sound = (LLGestureStepSound*)line->getUserdata();
  223. sound->mSoundAssetID = item->getAssetUUID();
  224. sound->mSoundName = item->getName();
  225. }
  226. updateLabel(line);
  227. mDirty = TRUE;
  228. refresh();
  229. }
  230. *accept = ACCEPT_YES_COPY_MULTI;
  231. }
  232. else
  233. {
  234. // Not in user's inventory means it was in object inventory
  235. *accept = ACCEPT_NO;
  236. }
  237. break;
  238. }
  239. default:
  240. *accept = ACCEPT_NO;
  241. if (tooltip_msg.empty())
  242. {
  243. tooltip_msg.assign("Only animations and soundsn"
  244. "can be added to a gesture.");
  245. }
  246. break;
  247. }
  248. return handled;
  249. }
  252. // virtual
  253. BOOL LLPreviewGesture::canClose()
  254. {
  256. if(!mDirty || mForceClose)
  257. {
  258. return TRUE;
  259. }
  260. else
  261. {
  262. // Bring up view-modal dialog: Save changes? Yes, No, Cancel
  263. LLNotificationsUtil::add("SaveChanges", LLSD(), LLSD(),
  264. boost::bind(&LLPreviewGesture::handleSaveChangesDialog, this, _1, _2) );
  265. return FALSE;
  266. }
  267. }
  269. // virtual
  270. void LLPreviewGesture::onClose(bool app_quitting)
  271. {
  272. LLGestureManager::instance().stopGesture(mPreviewGesture);
  273. }
  275. // virtual
  276. void LLPreviewGesture::onUpdateSucceeded()
  277. {
  278. refresh();
  279. }
  281. void LLPreviewGesture::onVisibilityChange ( const LLSD& new_visibility )
  282. {
  283. if (new_visibility.asBoolean())
  284. {
  285. refresh();
  286. }
  287. }
  290. bool LLPreviewGesture::handleSaveChangesDialog(const LLSD& notification, const LLSD& response)
  291. {
  292. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  293. switch(option)
  294. {
  295. case 0:  // "Yes"
  296. LLGestureManager::instance().stopGesture(mPreviewGesture);
  297. mCloseAfterSave = TRUE;
  298. onClickSave(this);
  299. break;
  301. case 1:  // "No"
  302. LLGestureManager::instance().stopGesture(mPreviewGesture);
  303. mDirty = FALSE; // Force the dirty flag because user has clicked NO on confirm save dialog...
  304. closeFloater();
  305. break;
  307. case 2: // "Cancel"
  308. default:
  309. // If we were quitting, we didn't really mean it.
  310. LLAppViewer::instance()->abortQuit();
  311. break;
  312. }
  313. return false;
  314. }
  317. LLPreviewGesture::LLPreviewGesture(const LLSD& key)
  318. : LLPreview(key),
  319. mTriggerEditor(NULL),
  320. mModifierCombo(NULL),
  321. mKeyCombo(NULL),
  322. mLibraryList(NULL),
  323. mAddBtn(NULL),
  324. mUpBtn(NULL),
  325. mDownBtn(NULL),
  326. mDeleteBtn(NULL),
  327. mStepList(NULL),
  328. mOptionsText(NULL),
  329. mAnimationRadio(NULL),
  330. mAnimationCombo(NULL),
  331. mSoundCombo(NULL),
  332. mChatEditor(NULL),
  333. mSaveBtn(NULL),
  334. mPreviewBtn(NULL),
  335. mPreviewGesture(NULL),
  336. mDirty(FALSE)
  337. {
  338. NONE_LABEL =  LLTrans::getString("---");
  339. SHIFT_LABEL = LLTrans::getString("KBShift");
  340. CTRL_LABEL = LLTrans::getString("KBCtrl");
  342. //Called from floater reg: LLUICtrlFactory::getInstance()->buildFloater(this, "floater_preview_gesture.xml", FALSE);
  344. }
  347. LLPreviewGesture::~LLPreviewGesture()
  348. {
  349. // Userdata for all steps is a LLGestureStep we need to clean up
  350. std::vector<LLScrollListItem*> data_list = mStepList->getAllData();
  351. std::vector<LLScrollListItem*>::iterator data_itor;
  352. for (data_itor = data_list.begin(); data_itor != data_list.end(); ++data_itor)
  353. {
  354. LLScrollListItem* item = *data_itor;
  355. LLGestureStep* step = (LLGestureStep*)item->getUserdata();
  356. delete step;
  357. step = NULL;
  358. }
  359. }
  362. BOOL LLPreviewGesture::postBuild()
  363. {
  364. setVisibleCallback(boost::bind(&LLPreviewGesture::onVisibilityChange, this, _2));
  366. LLLineEditor* edit;
  367. LLComboBox* combo;
  368. LLButton* btn;
  369. LLScrollListCtrl* list;
  370. LLTextBox* text;
  371. LLCheckBoxCtrl* check;
  373. edit = getChild<LLLineEditor>("name");
  374. edit->setKeystrokeCallback(onKeystrokeCommit, this);
  376. edit = getChild<LLLineEditor>("desc");
  377. edit->setKeystrokeCallback(onKeystrokeCommit, this);
  379. edit = getChild<LLLineEditor>("trigger_editor");
  380. edit->setKeystrokeCallback(onKeystrokeCommit, this);
  381. edit->setCommitCallback(onCommitSetDirty, this);
  382. edit->setCommitOnFocusLost(TRUE);
  383. edit->setIgnoreTab(TRUE);
  384. mTriggerEditor = edit;
  386. text = getChild<LLTextBox>("replace_text");
  387. text->setEnabled(FALSE);
  388. mReplaceText = text;
  390. edit = getChild<LLLineEditor>("replace_editor");
  391. edit->setEnabled(FALSE);
  392. edit->setKeystrokeCallback(onKeystrokeCommit, this);
  393. edit->setCommitCallback(onCommitSetDirty, this);
  394. edit->setCommitOnFocusLost(TRUE);
  395. edit->setIgnoreTab(TRUE);
  396. mReplaceEditor = edit;
  398. combo = getChild<LLComboBox>( "modifier_combo");
  399. combo->setCommitCallback(onCommitSetDirty, this);
  400. mModifierCombo = combo;
  402. combo = getChild<LLComboBox>( "key_combo");
  403. combo->setCommitCallback(onCommitSetDirty, this);
  404. mKeyCombo = combo;
  406. list = getChild<LLScrollListCtrl>("library_list");
  407. list->setCommitCallback(onCommitLibrary, this);
  408. list->setDoubleClickCallback(onClickAdd, this);
  409. mLibraryList = list;
  411. btn = getChild<LLButton>( "add_btn");
  412. btn->setClickedCallback(onClickAdd, this);
  413. btn->setEnabled(FALSE);
  414. mAddBtn = btn;
  416. btn = getChild<LLButton>( "up_btn");
  417. btn->setClickedCallback(onClickUp, this);
  418. btn->setEnabled(FALSE);
  419. mUpBtn = btn;
  421. btn = getChild<LLButton>( "down_btn");
  422. btn->setClickedCallback(onClickDown, this);
  423. btn->setEnabled(FALSE);
  424. mDownBtn = btn;
  426. btn = getChild<LLButton>( "delete_btn");
  427. btn->setClickedCallback(onClickDelete, this);
  428. btn->setEnabled(FALSE);
  429. mDeleteBtn = btn;
  431. list = getChild<LLScrollListCtrl>("step_list");
  432. list->setCommitCallback(onCommitStep, this);
  433. mStepList = list;
  435. // Options
  436. mOptionsText = getChild<LLTextBox>("options_text");
  438. combo = getChild<LLComboBox>( "animation_list");
  439. combo->setVisible(FALSE);
  440. combo->setCommitCallback(onCommitAnimation, this);
  441. mAnimationCombo = combo;
  443. LLRadioGroup* group;
  444. group = getChild<LLRadioGroup>("animation_trigger_type");
  445. group->setVisible(FALSE);
  446. group->setCommitCallback(onCommitAnimationTrigger, this);
  447. mAnimationRadio = group;
  449. combo = getChild<LLComboBox>( "sound_list");
  450. combo->setVisible(FALSE);
  451. combo->setCommitCallback(onCommitSound, this);
  452. mSoundCombo = combo;
  454. edit = getChild<LLLineEditor>("chat_editor");
  455. edit->setVisible(FALSE);
  456. edit->setCommitCallback(onCommitChat, this);
  457. //edit->setKeystrokeCallback(onKeystrokeCommit, this);
  458. edit->setCommitOnFocusLost(TRUE);
  459. edit->setIgnoreTab(TRUE);
  460. mChatEditor = edit;
  462. check = getChild<LLCheckBoxCtrl>( "wait_anim_check");
  463. check->setVisible(FALSE);
  464. check->setCommitCallback(onCommitWait, this);
  465. mWaitAnimCheck = check;
  467. check = getChild<LLCheckBoxCtrl>( "wait_time_check");
  468. check->setVisible(FALSE);
  469. check->setCommitCallback(onCommitWait, this);
  470. mWaitTimeCheck = check;
  472. edit = getChild<LLLineEditor>("wait_time_editor");
  473. edit->setEnabled(FALSE);
  474. edit->setVisible(FALSE);
  475. edit->setPrevalidate(LLTextValidate::validateFloat);
  476. // edit->setKeystrokeCallback(onKeystrokeCommit, this);
  477. edit->setCommitOnFocusLost(TRUE);
  478. edit->setCommitCallback(onCommitWaitTime, this);
  479. edit->setIgnoreTab(TRUE);
  480. mWaitTimeEditor = edit;
  482. // Buttons at the bottom
  483. check = getChild<LLCheckBoxCtrl>( "active_check");
  484. check->setCommitCallback(onCommitActive, this);
  485. mActiveCheck = check;
  487. btn = getChild<LLButton>( "save_btn");
  488. btn->setClickedCallback(onClickSave, this);
  489. mSaveBtn = btn;
  491. btn = getChild<LLButton>( "preview_btn");
  492. btn->setClickedCallback(onClickPreview, this);
  493. mPreviewBtn = btn;
  496. // Populate the comboboxes
  497. addModifiers();
  498. addKeys();
  499. addAnimations();
  500. addSounds();
  502. const LLInventoryItem* item = getItem();
  504. if (item) 
  505. {
  506. childSetText("desc", item->getDescription());
  507. childSetPrevalidate("desc", &LLTextValidate::validateASCIIPrintableNoPipe);
  509. childSetText("name", item->getName());
  510. childSetPrevalidate("name", &LLTextValidate::validateASCIIPrintableNoPipe);
  511. }
  513. return LLPreview::postBuild();
  514. }
  517. void LLPreviewGesture::addModifiers()
  518. {
  519. LLComboBox* combo = mModifierCombo;
  521. combo->add( NONE_LABEL,  ADD_BOTTOM );
  522. combo->add( SHIFT_LABEL, ADD_BOTTOM );
  523. combo->add( CTRL_LABEL,  ADD_BOTTOM );
  524. combo->setCurrentByIndex(0);
  525. }
  527. void LLPreviewGesture::addKeys()
  528. {
  529. LLComboBox* combo = mKeyCombo;
  531. combo->add( NONE_LABEL );
  532. for (KEY key = KEY_F2; key <= KEY_F12; key++)
  533. {
  534. combo->add( LLKeyboard::stringFromKey(key), ADD_BOTTOM );
  535. }
  536. combo->setCurrentByIndex(0);
  537. }
  540. // TODO: Sort the legacy and non-legacy together?
  541. void LLPreviewGesture::addAnimations()
  542. {
  543. LLComboBox* combo = mAnimationCombo;
  545. combo->removeall();
  547. std::string none_text = getString("none_text");
  549. combo->add(none_text, LLUUID::null);
  551. // Add all the default (legacy) animations
  552. S32 i;
  553. for (i = 0; i < gUserAnimStatesCount; ++i)
  554. {
  555. // Use the user-readable name
  556. std::string label = LLAnimStateLabels::getStateLabel( gUserAnimStates[i].mName );
  557. const LLUUID& id = gUserAnimStates[i].mID;
  558. combo->add(label, id);
  559. }
  561. // Get all inventory items that are animations
  562. LLViewerInventoryCategory::cat_array_t cats;
  563. LLViewerInventoryItem::item_array_t items;
  564. LLIsTypeWithPermissions is_copyable_animation(LLAssetType::AT_ANIMATION,
  565. PERM_ITEM_UNRESTRICTED,
  566. gAgent.getID(),
  567. gAgent.getGroupID());
  568. gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
  569. cats,
  570. items,
  571. LLInventoryModel::EXCLUDE_TRASH,
  572. is_copyable_animation);
  574. // Copy into something we can sort
  575. std::vector<LLInventoryItem*> animations;
  577. S32 count = items.count();
  578. for(i = 0; i < count; ++i)
  579. {
  580. animations.push_back( items.get(i) );
  581. }
  583. // Do the sort
  584. std::sort(animations.begin(), animations.end(), SortItemPtrsByName());
  586. // And load up the combobox
  587. std::vector<LLInventoryItem*>::iterator it;
  588. for (it = animations.begin(); it != animations.end(); ++it)
  589. {
  590. LLInventoryItem* item = *it;
  592. combo->add(item->getName(), item->getAssetUUID(), ADD_BOTTOM);
  593. }
  594. }
  597. void LLPreviewGesture::addSounds()
  598. {
  599. LLComboBox* combo = mSoundCombo;
  600. combo->removeall();
  602. std::string none_text = getString("none_text");
  604. combo->add(none_text, LLUUID::null);
  606. // Get all inventory items that are sounds
  607. LLViewerInventoryCategory::cat_array_t cats;
  608. LLViewerInventoryItem::item_array_t items;
  609. LLIsTypeWithPermissions is_copyable_sound(LLAssetType::AT_SOUND,
  610. PERM_ITEM_UNRESTRICTED,
  611. gAgent.getID(),
  612. gAgent.getGroupID());
  613. gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
  614. cats,
  615. items,
  616. LLInventoryModel::EXCLUDE_TRASH,
  617. is_copyable_sound);
  619. // Copy sounds into something we can sort
  620. std::vector<LLInventoryItem*> sounds;
  622. S32 i;
  623. S32 count = items.count();
  624. for(i = 0; i < count; ++i)
  625. {
  626. sounds.push_back( items.get(i) );
  627. }
  629. // Do the sort
  630. std::sort(sounds.begin(), sounds.end(), SortItemPtrsByName());
  632. // And load up the combobox
  633. std::vector<LLInventoryItem*>::iterator it;
  634. for (it = sounds.begin(); it != sounds.end(); ++it)
  635. {
  636. LLInventoryItem* item = *it;
  638. combo->add(item->getName(), item->getAssetUUID(), ADD_BOTTOM);
  639. }
  640. }
  643. void LLPreviewGesture::refresh()
  644. {
  645. LLPreview::refresh();
  646. // If previewing or item is incomplete, all controls are disabled
  647. LLViewerInventoryItem* item = (LLViewerInventoryItem*)getItem();
  648. bool is_complete = (item && item->isComplete()) ? true : false;
  649. if (mPreviewGesture || !is_complete)
  650. {
  652. childSetEnabled("desc", FALSE);
  653. //mDescEditor->setEnabled(FALSE);
  654. mTriggerEditor->setEnabled(FALSE);
  655. mReplaceText->setEnabled(FALSE);
  656. mReplaceEditor->setEnabled(FALSE);
  657. mModifierCombo->setEnabled(FALSE);
  658. mKeyCombo->setEnabled(FALSE);
  659. mLibraryList->setEnabled(FALSE);
  660. mAddBtn->setEnabled(FALSE);
  661. mUpBtn->setEnabled(FALSE);
  662. mDownBtn->setEnabled(FALSE);
  663. mDeleteBtn->setEnabled(FALSE);
  664. mStepList->setEnabled(FALSE);
  665. mOptionsText->setEnabled(FALSE);
  666. mAnimationCombo->setEnabled(FALSE);
  667. mAnimationRadio->setEnabled(FALSE);
  668. mSoundCombo->setEnabled(FALSE);
  669. mChatEditor->setEnabled(FALSE);
  670. mWaitAnimCheck->setEnabled(FALSE);
  671. mWaitTimeCheck->setEnabled(FALSE);
  672. mWaitTimeEditor->setEnabled(FALSE);
  673. mActiveCheck->setEnabled(FALSE);
  674. mSaveBtn->setEnabled(FALSE);
  676. // Make sure preview button is enabled, so we can stop it
  677. mPreviewBtn->setEnabled(TRUE);
  678. return;
  679. }
  681. BOOL modifiable = item->getPermissions().allowModifyBy(gAgent.getID());
  683. childSetEnabled("desc", modifiable);
  684. mTriggerEditor->setEnabled(TRUE);
  685. mLibraryList->setEnabled(modifiable);
  686. mStepList->setEnabled(modifiable);
  687. mOptionsText->setEnabled(modifiable);
  688. mAnimationCombo->setEnabled(modifiable);
  689. mAnimationRadio->setEnabled(modifiable);
  690. mSoundCombo->setEnabled(modifiable);
  691. mChatEditor->setEnabled(modifiable);
  692. mWaitAnimCheck->setEnabled(modifiable);
  693. mWaitTimeCheck->setEnabled(modifiable);
  694. mWaitTimeEditor->setEnabled(modifiable);
  695. mActiveCheck->setEnabled(TRUE);
  697. const std::string& trigger = mTriggerEditor->getText();
  698. BOOL have_trigger = !trigger.empty();
  700. const std::string& replace = mReplaceEditor->getText();
  701. BOOL have_replace = !replace.empty();
  703. LLScrollListItem* library_item = mLibraryList->getFirstSelected();
  704. BOOL have_library = (library_item != NULL);
  706. LLScrollListItem* step_item = mStepList->getFirstSelected();
  707. S32 step_index = mStepList->getFirstSelectedIndex();
  708. S32 step_count = mStepList->getItemCount();
  709. BOOL have_step = (step_item != NULL);
  711. mReplaceText->setEnabled(have_trigger || have_replace);
  712. mReplaceEditor->setEnabled(have_trigger || have_replace);
  714. mModifierCombo->setEnabled(TRUE);
  715. mKeyCombo->setEnabled(TRUE);
  717. mAddBtn->setEnabled(modifiable && have_library);
  718. mUpBtn->setEnabled(modifiable && have_step && step_index > 0);
  719. mDownBtn->setEnabled(modifiable && have_step && step_index < step_count-1);
  720. mDeleteBtn->setEnabled(modifiable && have_step);
  722. // Assume all not visible
  723. mAnimationCombo->setVisible(FALSE);
  724. mAnimationRadio->setVisible(FALSE);
  725. mSoundCombo->setVisible(FALSE);
  726. mChatEditor->setVisible(FALSE);
  727. mWaitAnimCheck->setVisible(FALSE);
  728. mWaitTimeCheck->setVisible(FALSE);
  729. mWaitTimeEditor->setVisible(FALSE);
  731. std::string optionstext;
  733. if (have_step)
  734. {
  735. // figure out the type, show proper options, update text
  736. LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
  737. EStepType type = step->getType();
  739. switch(type)
  740. {
  741. case STEP_ANIMATION:
  742. {
  743. LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
  744. optionstext = getString("step_anim");
  745. mAnimationCombo->setVisible(TRUE);
  746. mAnimationRadio->setVisible(TRUE);
  747. mAnimationRadio->setSelectedIndex((anim_step->mFlags & ANIM_FLAG_STOP) ? 1 : 0);
  748. mAnimationCombo->setCurrentByID(anim_step->mAnimAssetID);
  749. break;
  750. }
  751. case STEP_SOUND:
  752. {
  753. LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
  754. optionstext = getString("step_sound");
  755. mSoundCombo->setVisible(TRUE);
  756. mSoundCombo->setCurrentByID(sound_step->mSoundAssetID);
  757. break;
  758. }
  759. case STEP_CHAT:
  760. {
  761. LLGestureStepChat* chat_step = (LLGestureStepChat*)step;
  762. optionstext = getString("step_chat");
  763. mChatEditor->setVisible(TRUE);
  764. mChatEditor->setText(chat_step->mChatText);
  765. break;
  766. }
  767. case STEP_WAIT:
  768. {
  769. LLGestureStepWait* wait_step = (LLGestureStepWait*)step;
  770. optionstext = getString("step_wait");
  771. mWaitAnimCheck->setVisible(TRUE);
  772. mWaitAnimCheck->set(wait_step->mFlags & WAIT_FLAG_ALL_ANIM);
  773. mWaitTimeCheck->setVisible(TRUE);
  774. mWaitTimeCheck->set(wait_step->mFlags & WAIT_FLAG_TIME);
  775. mWaitTimeEditor->setVisible(TRUE);
  776. std::string buffer = llformat("%.1f", (double)wait_step->mWaitSeconds);
  777. mWaitTimeEditor->setText(buffer);
  778. break;
  779. }
  780. default:
  781. break;
  782. }
  783. }
  785. mOptionsText->setText(optionstext);
  787. BOOL active = LLGestureManager::instance().isGestureActive(mItemUUID);
  788. mActiveCheck->set(active);
  790. // Can only preview if there are steps
  791. mPreviewBtn->setEnabled(step_count > 0);
  793. // And can only save if changes have been made
  794. mSaveBtn->setEnabled(mDirty);
  795. addAnimations();
  796. addSounds();
  797. }
  800. void LLPreviewGesture::initDefaultGesture()
  801. {
  802. LLScrollListItem* item;
  803. item = addStep( STEP_ANIMATION );
  804. LLGestureStepAnimation* anim = (LLGestureStepAnimation*)item->getUserdata();
  805. anim->mAnimAssetID = ANIM_AGENT_HELLO;
  806. anim->mAnimName = LLTrans::getString("Wave");
  807. updateLabel(item);
  809. item = addStep( STEP_WAIT );
  810. LLGestureStepWait* wait = (LLGestureStepWait*)item->getUserdata();
  811. wait->mFlags = WAIT_FLAG_ALL_ANIM;
  812. updateLabel(item);
  814. item = addStep( STEP_CHAT );
  815. LLGestureStepChat* chat_step = (LLGestureStepChat*)item->getUserdata();
  816. chat_step->mChatText =  LLTrans::getString("HelloAvatar");
  817. updateLabel(item);
  819. // Start with item list selected
  820. mStepList->selectFirstItem();
  822. // this is *new* content, so we are dirty
  823. mDirty = TRUE;
  824. }
  827. void LLPreviewGesture::loadAsset()
  828. {
  829. const LLInventoryItem* item = getItem();
  830. if (!item) 
  831. {
  832. mAssetStatus = PREVIEW_ASSET_ERROR;
  833. return;
  834. }
  836. LLUUID asset_id = item->getAssetUUID();
  837. if (asset_id.isNull())
  838. {
  839. // Freshly created gesture, don't need to load asset.
  840. // Blank gesture will be fine.
  841. initDefaultGesture();
  842. refresh();
  843. mAssetStatus = PREVIEW_ASSET_LOADED;
  844. return;
  845. }
  847. // TODO: Based on item->getPermissions().allow*
  848. // could enable/disable UI.
  850. // Copy the UUID, because the user might close the preview
  851. // window if the download gets stalled.
  852. LLUUID* item_idp = new LLUUID(mItemUUID);
  854. const BOOL high_priority = TRUE;
  855. gAssetStorage->getAssetData(asset_id,
  856. LLAssetType::AT_GESTURE,
  857. onLoadComplete,
  858. (void**)item_idp,
  859. high_priority);
  860. mAssetStatus = PREVIEW_ASSET_LOADING;
  861. }
  864. // static
  865. void LLPreviewGesture::onLoadComplete(LLVFS *vfs,
  866.    const LLUUID& asset_uuid,
  867.    LLAssetType::EType type,
  868.    void* user_data, S32 status, LLExtStat ext_status)
  869. {
  870. LLUUID* item_idp = (LLUUID*)user_data;
  872. LLPreviewGesture* self = LLFloaterReg::findTypedInstance<LLPreviewGesture>("preview_gesture", *item_idp);
  873. if (self)
  874. {
  875. if (0 == status)
  876. {
  877. LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
  878. S32 size = file.getSize();
  880. std::vector<char> buffer(size+1);
  881. file.read((U8*)&buffer[0], size);
  882. buffer[size] = '';
  884. LLMultiGesture* gesture = new LLMultiGesture();
  886. LLDataPackerAsciiBuffer dp(&buffer[0], size+1);
  887. BOOL ok = gesture->deserialize(dp);
  889. if (ok)
  890. {
  891. // Everything has been successful.  Load up the UI.
  892. self->loadUIFromGesture(gesture);
  894. self->mStepList->selectFirstItem();
  896. self->mDirty = FALSE;
  897. self->refresh();
  898. }
  899. else
  900. {
  901. llwarns << "Unable to load gesture" << llendl;
  902. }
  904. delete gesture;
  905. gesture = NULL;
  907. self->mAssetStatus = PREVIEW_ASSET_LOADED;
  908. }
  909. else
  910. {
  911. LLViewerStats::getInstance()->incStat( LLViewerStats::ST_DOWNLOAD_FAILED );
  913. if( LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE == status ||
  914. LL_ERR_FILE_EMPTY == status)
  915. {
  916. LLDelayedGestureError::gestureMissing( *item_idp );
  917. }
  918. else
  919. {
  920. LLDelayedGestureError::gestureFailedToLoad( *item_idp );
  921. }
  923. llwarns << "Problem loading gesture: " << status << llendl;
  924. self->mAssetStatus = PREVIEW_ASSET_ERROR;
  925. }
  926. }
  927. delete item_idp;
  928. item_idp = NULL;
  929. }
  932. void LLPreviewGesture::loadUIFromGesture(LLMultiGesture* gesture)
  933. {
  934. /*LLInventoryItem* item = getItem();
  938. if (item)
  939. {
  940. LLLineEditor* descEditor = getChild<LLLineEditor>("desc");
  941. descEditor->setText(item->getDescription());
  942. }*/
  944. mTriggerEditor->setText(gesture->mTrigger);
  946. mReplaceEditor->setText(gesture->mReplaceText);
  948. switch (gesture->mMask)
  949. {
  950. default:
  951.   case MASK_NONE:
  952. mModifierCombo->setSimple( NONE_LABEL );
  953. break;
  954.   case MASK_SHIFT:
  955. mModifierCombo->setSimple( SHIFT_LABEL );
  956. break;
  957.   case MASK_CONTROL:
  958. mModifierCombo->setSimple( CTRL_LABEL );
  959. break;
  960. }
  962. mKeyCombo->setCurrentByIndex(0);
  963. if (gesture->mKey != KEY_NONE)
  964. {
  965. mKeyCombo->setSimple(LLKeyboard::stringFromKey(gesture->mKey));
  966. }
  968. // Make UI steps for each gesture step
  969. S32 i;
  970. S32 count = gesture->mSteps.size();
  971. for (i = 0; i < count; ++i)
  972. {
  973. LLGestureStep* step = gesture->mSteps[i];
  975. LLGestureStep* new_step = NULL;
  977. switch(step->getType())
  978. {
  979. case STEP_ANIMATION:
  980. {
  981. LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
  982. LLGestureStepAnimation* new_anim_step =
  983. new LLGestureStepAnimation(*anim_step);
  984. new_step = new_anim_step;
  985. break;
  986. }
  987. case STEP_SOUND:
  988. {
  989. LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
  990. LLGestureStepSound* new_sound_step =
  991. new LLGestureStepSound(*sound_step);
  992. new_step = new_sound_step;
  993. break;
  994. }
  995. case STEP_CHAT:
  996. {
  997. LLGestureStepChat* chat_step = (LLGestureStepChat*)step;
  998. LLGestureStepChat* new_chat_step =
  999. new LLGestureStepChat(*chat_step);
  1000. new_step = new_chat_step;
  1001. break;
  1002. }
  1003. case STEP_WAIT:
  1004. {
  1005. LLGestureStepWait* wait_step = (LLGestureStepWait*)step;
  1006. LLGestureStepWait* new_wait_step =
  1007. new LLGestureStepWait(*wait_step);
  1008. new_step = new_wait_step;
  1009. break;
  1010. }
  1011. default:
  1012. {
  1013. break;
  1014. }
  1015. }
  1017. if (!new_step) continue;
  1019. // Create an enabled item with this step
  1020. LLSD row;
  1021. row["columns"][0]["value"] = getLabel( new_step->getLabel());
  1022. row["columns"][0]["font"] = "SANSSERIF_SMALL";
  1023. LLScrollListItem* item = mStepList->addElement(row);
  1024. item->setUserdata(new_step);
  1025. }
  1026. }
  1028. // Helpful structure so we can look up the inventory item
  1029. // after the save finishes.
  1030. struct LLSaveInfo
  1031. {
  1032. LLSaveInfo(const LLUUID& item_id, const LLUUID& object_id, const std::string& desc,
  1033. const LLTransactionID tid)
  1034. : mItemUUID(item_id), mObjectUUID(object_id), mDesc(desc), mTransactionID(tid)
  1035. {
  1036. }
  1038. LLUUID mItemUUID;
  1039. LLUUID mObjectUUID;
  1040. std::string mDesc;
  1041. LLTransactionID mTransactionID;
  1042. };
  1045. void LLPreviewGesture::saveIfNeeded()
  1046. {
  1047. if (!gAssetStorage)
  1048. {
  1049. llwarns << "Can't save gesture, no asset storage system." << llendl;
  1050. return;
  1051. }
  1053. if (!mDirty)
  1054. {
  1055. return;
  1056. }
  1058. // Copy the UI into a gesture
  1059. LLMultiGesture* gesture = createGesture();
  1061. // Serialize the gesture
  1062. S32 max_size = gesture->getMaxSerialSize();
  1063. char* buffer = new char[max_size];
  1065. LLDataPackerAsciiBuffer dp(buffer, max_size);
  1067. BOOL ok = gesture->serialize(dp);
  1069. if (dp.getCurrentSize() > 1000)
  1070. {
  1071. LLNotificationsUtil::add("GestureSaveFailedTooManySteps");
  1073. delete gesture;
  1074. gesture = NULL;
  1075. }
  1076. else if (!ok)
  1077. {
  1078. LLNotificationsUtil::add("GestureSaveFailedTryAgain");
  1079. delete gesture;
  1080. gesture = NULL;
  1081. }
  1082. else
  1083. {
  1084. LLPreview::onCommit();
  1086. // Every save gets a new UUID.  Yup.
  1087. LLTransactionID tid;
  1088. LLAssetID asset_id;
  1089. tid.generate();
  1090. asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
  1092. LLVFile file(gVFS, asset_id, LLAssetType::AT_GESTURE, LLVFile::APPEND);
  1094. S32 size = dp.getCurrentSize();
  1095. file.setMaxSize(size);
  1096. file.write((U8*)buffer, size);
  1098. BOOL delayedUpload = FALSE;
  1100. // Upload that asset to the database
  1101. LLViewerInventoryItem* item = (LLViewerInventoryItem*) getItem();
  1102. if (item)
  1103. {
  1104. std::string agent_url = gAgent.getRegion()->getCapability("UpdateGestureAgentInventory");
  1105. std::string task_url = gAgent.getRegion()->getCapability("UpdateGestureTaskInventory");
  1106. if (mObjectUUID.isNull() && !agent_url.empty())
  1107. {
  1108. //need to disable the preview floater so item
  1109. //isn't re-saved before new asset arrives
  1110. //fake out refresh.
  1111. item->setComplete(FALSE);
  1112. refresh();
  1113. item->setComplete(TRUE);
  1115. // Saving into agent inventory
  1116. LLSD body;
  1117. body["item_id"] = mItemUUID;
  1118. LLHTTPClient::post(agent_url, body,
  1119. new LLUpdateAgentInventoryResponder(body, asset_id, LLAssetType::AT_GESTURE));
  1120. delayedUpload = TRUE;
  1121. }
  1122. else if (!mObjectUUID.isNull() && !task_url.empty())
  1123. {
  1124. // Saving into task inventory
  1125. LLSD body;
  1126. body["task_id"] = mObjectUUID;
  1127. body["item_id"] = mItemUUID;
  1128. LLHTTPClient::post(task_url, body,
  1129. new LLUpdateTaskInventoryResponder(body, asset_id, LLAssetType::AT_GESTURE));
  1130. }
  1131. else if (gAssetStorage)
  1132. {
  1133. LLLineEditor* descEditor = getChild<LLLineEditor>("desc");
  1134. LLSaveInfo* info = new LLSaveInfo(mItemUUID, mObjectUUID, descEditor->getText(), tid);
  1135. gAssetStorage->storeAssetData(tid, LLAssetType::AT_GESTURE, onSaveComplete, info, FALSE);
  1136. }
  1137. }
  1139. // If this gesture is active, then we need to update the in-memory
  1140. // active map with the new pointer.
  1141. if (!delayedUpload && LLGestureManager::instance().isGestureActive(mItemUUID))
  1142. {
  1143. // gesture manager now owns the pointer
  1144. LLGestureManager::instance().replaceGesture(mItemUUID, gesture, asset_id);
  1146. // replaceGesture may deactivate other gestures so let the
  1147. // inventory know.
  1148. gInventory.notifyObservers();
  1149. }
  1150. else
  1151. {
  1152. // we're done with this gesture
  1153. delete gesture;
  1154. gesture = NULL;
  1155. }
  1157. mDirty = FALSE;
  1158. // refresh will be called when callback
  1159. // if triggered when delayedUpload
  1160. if(!delayedUpload)
  1161. {
  1162. refresh();
  1163. }
  1164. }
  1166. delete [] buffer;
  1167. buffer = NULL;
  1168. }
  1171. // TODO: This is very similar to LLPreviewNotecard::onSaveComplete.
  1172. // Could merge code.
  1173. // static
  1174. void LLPreviewGesture::onSaveComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
  1175. {
  1176. LLSaveInfo* info = (LLSaveInfo*)user_data;
  1177. if (info && (status == 0))
  1178. {
  1179. if(info->mObjectUUID.isNull())
  1180. {
  1181. // Saving into user inventory
  1182. LLViewerInventoryItem* item;
  1183. item = (LLViewerInventoryItem*)gInventory.getItem(info->mItemUUID);
  1184. if(item)
  1185. {
  1186. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  1187. new_item->setDescription(info->mDesc);
  1188. new_item->setTransactionID(info->mTransactionID);
  1189. new_item->setAssetUUID(asset_uuid);
  1190. new_item->updateServer(FALSE);
  1191. gInventory.updateItem(new_item);
  1192. gInventory.notifyObservers();
  1193. }
  1194. else
  1195. {
  1196. llwarns << "Inventory item for gesture " << info->mItemUUID
  1197. << " is no longer in agent inventory." << llendl;
  1198. }
  1199. }
  1200. else
  1201. {
  1202. // Saving into in-world object inventory
  1203. LLViewerObject* object = gObjectList.findObject(info->mObjectUUID);
  1204. LLViewerInventoryItem* item = NULL;
  1205. if(object)
  1206. {
  1207. item = (LLViewerInventoryItem*)object->getInventoryObject(info->mItemUUID);
  1208. }
  1209. if(object && item)
  1210. {
  1211. item->setDescription(info->mDesc);
  1212. item->setAssetUUID(asset_uuid);
  1213. item->setTransactionID(info->mTransactionID);
  1214. object->updateInventory(item, TASK_INVENTORY_ITEM_KEY, false);
  1215. dialog_refresh_all();
  1216. }
  1217. else
  1218. {
  1219. LLNotificationsUtil::add("GestureSaveFailedObjectNotFound");
  1220. }
  1221. }
  1223. // Find our window and close it if requested.
  1224. LLPreviewGesture* previewp = LLFloaterReg::findTypedInstance<LLPreviewGesture>("preview_gesture", info->mItemUUID);
  1225. if (previewp && previewp->mCloseAfterSave)
  1226. {
  1227. previewp->closeFloater();
  1228. }
  1229. }
  1230. else
  1231. {
  1232. llwarns << "Problem saving gesture: " << status << llendl;
  1233. LLSD args;
  1234. args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
  1235. LLNotificationsUtil::add("GestureSaveFailedReason", args);
  1236. }
  1237. delete info;
  1238. info = NULL;
  1239. }
  1242. LLMultiGesture* LLPreviewGesture::createGesture()
  1243. {
  1244. LLMultiGesture* gesture = new LLMultiGesture();
  1246. gesture->mTrigger = mTriggerEditor->getText();
  1247. gesture->mReplaceText = mReplaceEditor->getText();
  1249. const std::string& modifier = mModifierCombo->getSimple();
  1250. if (modifier == CTRL_LABEL)
  1251. {
  1252. gesture->mMask = MASK_CONTROL;
  1253. }
  1254. else if (modifier == SHIFT_LABEL)
  1255. {
  1256. gesture->mMask = MASK_SHIFT;
  1257. }
  1258. else
  1259. {
  1260. gesture->mMask = MASK_NONE;
  1261. }
  1263. if (mKeyCombo->getCurrentIndex() == 0)
  1264. {
  1265. gesture->mKey = KEY_NONE;
  1266. }
  1267. else
  1268. {
  1269. const std::string& key_string = mKeyCombo->getSimple();
  1270. LLKeyboard::keyFromString(key_string, &(gesture->mKey));
  1271. }
  1273. std::vector<LLScrollListItem*> data_list = mStepList->getAllData();
  1274. std::vector<LLScrollListItem*>::iterator data_itor;
  1275. for (data_itor = data_list.begin(); data_itor != data_list.end(); ++data_itor)
  1276. {
  1277. LLScrollListItem* item = *data_itor;
  1278. LLGestureStep* step = (LLGestureStep*)item->getUserdata();
  1280. switch(step->getType())
  1281. {
  1282. case STEP_ANIMATION:
  1283. {
  1284. // Copy UI-generated step into actual gesture step
  1285. LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
  1286. LLGestureStepAnimation* new_anim_step =
  1287. new LLGestureStepAnimation(*anim_step);
  1288. gesture->mSteps.push_back(new_anim_step);
  1289. break;
  1290. }
  1291. case STEP_SOUND:
  1292. {
  1293. // Copy UI-generated step into actual gesture step
  1294. LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
  1295. LLGestureStepSound* new_sound_step =
  1296. new LLGestureStepSound(*sound_step);
  1297. gesture->mSteps.push_back(new_sound_step);
  1298. break;
  1299. }
  1300. case STEP_CHAT:
  1301. {
  1302. // Copy UI-generated step into actual gesture step
  1303. LLGestureStepChat* chat_step = (LLGestureStepChat*)step;
  1304. LLGestureStepChat* new_chat_step =
  1305. new LLGestureStepChat(*chat_step);
  1306. gesture->mSteps.push_back(new_chat_step);
  1307. break;
  1308. }
  1309. case STEP_WAIT:
  1310. {
  1311. // Copy UI-generated step into actual gesture step
  1312. LLGestureStepWait* wait_step = (LLGestureStepWait*)step;
  1313. LLGestureStepWait* new_wait_step =
  1314. new LLGestureStepWait(*wait_step);
  1315. gesture->mSteps.push_back(new_wait_step);
  1316. break;
  1317. }
  1318. default:
  1319. {
  1320. break;
  1321. }
  1322. }
  1323. }
  1325. return gesture;
  1326. }
  1329. // static
  1330. void LLPreviewGesture::updateLabel(LLScrollListItem* item)
  1331. {
  1332. LLGestureStep* step = (LLGestureStep*)item->getUserdata();
  1334. LLScrollListCell* cell = item->getColumn(0);
  1335. LLScrollListText* text_cell = (LLScrollListText*)cell;
  1336. std::string label = getLabel( step->getLabel());
  1337. text_cell->setText(label);
  1338. }
  1340. // static
  1341. void LLPreviewGesture::onCommitSetDirty(LLUICtrl* ctrl, void* data)
  1342. {
  1343. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1344. self->mDirty = TRUE;
  1345. self->refresh();
  1346. }
  1348. // static
  1349. void LLPreviewGesture::onCommitLibrary(LLUICtrl* ctrl, void* data)
  1350. {
  1351. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1353. LLScrollListItem* library_item = self->mLibraryList->getFirstSelected();
  1354. if (library_item)
  1355. {
  1356. self->mStepList->deselectAllItems();
  1357. self->refresh();
  1358. }
  1359. }
  1362. // static
  1363. void LLPreviewGesture::onCommitStep(LLUICtrl* ctrl, void* data)
  1364. {
  1365. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1367. LLScrollListItem* step_item = self->mStepList->getFirstSelected();
  1368. if (!step_item) return;
  1370. self->mLibraryList->deselectAllItems();
  1371. self->refresh();
  1372. }
  1375. // static
  1376. void LLPreviewGesture::onCommitAnimation(LLUICtrl* ctrl, void* data)
  1377. {
  1378. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1380. LLScrollListItem* step_item = self->mStepList->getFirstSelected();
  1381. if (step_item)
  1382. {
  1383. LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
  1384. if (step->getType() == STEP_ANIMATION)
  1385. {
  1386. // Assign the animation name
  1387. LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
  1388. if (self->mAnimationCombo->getCurrentIndex() == 0)
  1389. {
  1390. anim_step->mAnimName.clear();
  1391. anim_step->mAnimAssetID.setNull();
  1392. }
  1393. else
  1394. {
  1395. anim_step->mAnimName = self->mAnimationCombo->getSimple();
  1396. anim_step->mAnimAssetID = self->mAnimationCombo->getCurrentID();
  1397. }
  1398. //anim_step->mFlags = 0x0;
  1400. // Update the UI label in the list
  1401. updateLabel(step_item);
  1403. self->mDirty = TRUE;
  1404. self->refresh();
  1405. }
  1406. }
  1407. }
  1409. // static
  1410. void LLPreviewGesture::onCommitAnimationTrigger(LLUICtrl* ctrl, void *data)
  1411. {
  1412. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1414. LLScrollListItem* step_item = self->mStepList->getFirstSelected();
  1415. if (step_item)
  1416. {
  1417. LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
  1418. if (step->getType() == STEP_ANIMATION)
  1419. {
  1420. LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
  1421. if (self->mAnimationRadio->getSelectedIndex() == 0)
  1422. {
  1423. // start
  1424. anim_step->mFlags &= ~ANIM_FLAG_STOP;
  1425. }
  1426. else
  1427. {
  1428. // stop
  1429. anim_step->mFlags |= ANIM_FLAG_STOP;
  1430. }
  1431. // Update the UI label in the list
  1432. updateLabel(step_item);
  1434. self->mDirty = TRUE;
  1435. self->refresh();
  1436. }
  1437. }
  1438. }
  1440. // static
  1441. void LLPreviewGesture::onCommitSound(LLUICtrl* ctrl, void* data)
  1442. {
  1443. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1445. LLScrollListItem* step_item = self->mStepList->getFirstSelected();
  1446. if (step_item)
  1447. {
  1448. LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
  1449. if (step->getType() == STEP_SOUND)
  1450. {
  1451. // Assign the sound name
  1452. LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
  1453. sound_step->mSoundName = self->mSoundCombo->getSimple();
  1454. sound_step->mSoundAssetID = self->mSoundCombo->getCurrentID();
  1455. sound_step->mFlags = 0x0;
  1457. // Update the UI label in the list
  1458. updateLabel(step_item);
  1460. self->mDirty = TRUE;
  1461. self->refresh();
  1462. }
  1463. }
  1464. }
  1466. // static
  1467. void LLPreviewGesture::onCommitChat(LLUICtrl* ctrl, void* data)
  1468. {
  1469. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1471. LLScrollListItem* step_item = self->mStepList->getFirstSelected();
  1472. if (!step_item) return;
  1474. LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
  1475. if (step->getType() != STEP_CHAT) return;
  1477. LLGestureStepChat* chat_step = (LLGestureStepChat*)step;
  1478. chat_step->mChatText = self->mChatEditor->getText();
  1479. chat_step->mFlags = 0x0;
  1481. // Update the UI label in the list
  1482. updateLabel(step_item);
  1484. self->mDirty = TRUE;
  1485. self->refresh();
  1486. }
  1488. // static
  1489. void LLPreviewGesture::onCommitWait(LLUICtrl* ctrl, void* data)
  1490. {
  1491. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1493. LLScrollListItem* step_item = self->mStepList->getFirstSelected();
  1494. if (!step_item) return;
  1496. LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
  1497. if (step->getType() != STEP_WAIT) return;
  1499. LLGestureStepWait* wait_step = (LLGestureStepWait*)step;
  1500. U32 flags = 0x0;
  1501. if (self->mWaitAnimCheck->get()) flags |= WAIT_FLAG_ALL_ANIM;
  1502. if (self->mWaitTimeCheck->get()) flags |= WAIT_FLAG_TIME;
  1503. wait_step->mFlags = flags;
  1505. {
  1506. LLLocale locale(LLLocale::USER_LOCALE);
  1508. F32 wait_seconds = (F32)atof(self->mWaitTimeEditor->getText().c_str());
  1509. if (wait_seconds < 0.f) wait_seconds = 0.f;
  1510. if (wait_seconds > 3600.f) wait_seconds = 3600.f;
  1511. wait_step->mWaitSeconds = wait_seconds;
  1512. }
  1514. // Enable the input area if necessary
  1515. self->mWaitTimeEditor->setEnabled(self->mWaitTimeCheck->get());
  1517. // Update the UI label in the list
  1518. updateLabel(step_item);
  1520. self->mDirty = TRUE;
  1521. self->refresh();
  1522. }
  1524. // static
  1525. void LLPreviewGesture::onCommitWaitTime(LLUICtrl* ctrl, void* data)
  1526. {
  1527. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1529. LLScrollListItem* step_item = self->mStepList->getFirstSelected();
  1530. if (!step_item) return;
  1532. LLGestureStep* step = (LLGestureStep*)step_item->getUserdata();
  1533. if (step->getType() != STEP_WAIT) return;
  1535. self->mWaitTimeCheck->set(TRUE);
  1536. onCommitWait(ctrl, data);
  1537. }
  1540. // static
  1541. void LLPreviewGesture::onKeystrokeCommit(LLLineEditor* caller,
  1542.  void* data)
  1543. {
  1544. // Just commit every keystroke
  1545. onCommitSetDirty(caller, data);
  1546. }
  1548. // static
  1549. void LLPreviewGesture::onClickAdd(void* data)
  1550. {
  1551. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1553. LLScrollListItem* library_item = self->mLibraryList->getFirstSelected();
  1554. if (!library_item) return;
  1556. S32 library_item_index = self->mLibraryList->getFirstSelectedIndex();
  1558. const LLScrollListCell* library_cell = library_item->getColumn(0);
  1559. const std::string& library_text = library_cell->getValue().asString();
  1561. if( library_item_index >= STEP_EOF )
  1562. {
  1563. llerrs << "Unknown step type: " << library_text << llendl;
  1564. return;
  1565. }
  1567. self->addStep( (EStepType)library_item_index );
  1568. self->mDirty = TRUE;
  1569. self->refresh();
  1570. }
  1572. LLScrollListItem* LLPreviewGesture::addStep( const EStepType step_type )
  1573. {
  1574. // Order of enum EStepType MUST match the library_list element in floater_preview_gesture.xml
  1576. LLGestureStep* step = NULL;
  1577. switch( step_type)
  1578. {
  1579. case STEP_ANIMATION:
  1580. step = new LLGestureStepAnimation();
  1582. break;
  1583. case STEP_SOUND:
  1584. step = new LLGestureStepSound();
  1585. break;
  1586. case STEP_CHAT:
  1587. step = new LLGestureStepChat();
  1588. break;
  1589. case STEP_WAIT:
  1590. step = new LLGestureStepWait();
  1591. break;
  1592. default:
  1593. llerrs << "Unknown step type: " << (S32)step_type << llendl;
  1594. return NULL;
  1595. }
  1598. // Create an enabled item with this step
  1599. LLSD row;
  1600. row["columns"][0]["value"] = getLabel(step->getLabel());
  1601. row["columns"][0]["font"] = "SANSSERIF_SMALL";
  1602. LLScrollListItem* step_item = mStepList->addElement(row);
  1603. step_item->setUserdata(step);
  1605. // And move selection to the list on the right
  1606. mLibraryList->deselectAllItems();
  1607. mStepList->deselectAllItems();
  1609. step_item->setSelected(TRUE);
  1611. return step_item;
  1612. }
  1614. // static
  1615. std::string LLPreviewGesture::getLabel(std::vector<std::string> labels)
  1616. {
  1617. std::vector<std::string> v_labels = labels ;
  1618. std::string result("");
  1620. if( v_labels.size() != 2)
  1621. {
  1622. return result;
  1623. }
  1625. if(v_labels[0]=="Chat")
  1626. {
  1627. result=LLTrans::getString("Chat");
  1628. }
  1629.     else if(v_labels[0]=="Sound")
  1630. {
  1631. result=LLTrans::getString("Sound");
  1632. }
  1633. else if(v_labels[0]=="Wait")
  1634. {
  1635. result=LLTrans::getString("Wait");
  1636. }
  1637. else if(v_labels[0]=="AnimFlagStop")
  1638. {
  1639. result=LLTrans::getString("AnimFlagStop");
  1640. }
  1641. else if(v_labels[0]=="AnimFlagStart")
  1642. {
  1643. result=LLTrans::getString("AnimFlagStart");
  1644. }
  1646. result.append(v_labels[1]);
  1647. return result;
  1649. }
  1650. // static
  1651. void LLPreviewGesture::onClickUp(void* data)
  1652. {
  1653. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1655. S32 selected_index = self->mStepList->getFirstSelectedIndex();
  1656. if (selected_index > 0)
  1657. {
  1658. self->mStepList->swapWithPrevious(selected_index);
  1659. self->mDirty = TRUE;
  1660. self->refresh();
  1661. }
  1662. }
  1664. // static
  1665. void LLPreviewGesture::onClickDown(void* data)
  1666. {
  1667. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1669. S32 selected_index = self->mStepList->getFirstSelectedIndex();
  1670. if (selected_index < 0) return;
  1672. S32 count = self->mStepList->getItemCount();
  1673. if (selected_index < count-1)
  1674. {
  1675. self->mStepList->swapWithNext(selected_index);
  1676. self->mDirty = TRUE;
  1677. self->refresh();
  1678. }
  1679. }
  1681. // static
  1682. void LLPreviewGesture::onClickDelete(void* data)
  1683. {
  1684. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1686. LLScrollListItem* item = self->mStepList->getFirstSelected();
  1687. S32 selected_index = self->mStepList->getFirstSelectedIndex();
  1688. if (item && selected_index >= 0)
  1689. {
  1690. LLGestureStep* step = (LLGestureStep*)item->getUserdata();
  1691. delete step;
  1692. step = NULL;
  1694. self->mStepList->deleteSingleItem(selected_index);
  1696. self->mDirty = TRUE;
  1697. self->refresh();
  1698. }
  1699. }
  1701. // static
  1702. void LLPreviewGesture::onCommitActive(LLUICtrl* ctrl, void* data)
  1703. {
  1704. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1705. if (!LLGestureManager::instance().isGestureActive(self->mItemUUID))
  1706. {
  1707. LLGestureManager::instance().activateGesture(self->mItemUUID);
  1708. }
  1709. else
  1710. {
  1711. LLGestureManager::instance().deactivateGesture(self->mItemUUID);
  1712. }
  1714. // Make sure the (active) label in the inventory gets updated.
  1715. LLViewerInventoryItem* item = gInventory.getItem(self->mItemUUID);
  1716. if (item)
  1717. {
  1718. gInventory.updateItem(item);
  1719. gInventory.notifyObservers();
  1720. }
  1722. self->refresh();
  1723. }
  1725. // static
  1726. void LLPreviewGesture::onClickSave(void* data)
  1727. {
  1728. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1729. self->saveIfNeeded();
  1730. }
  1732. // static
  1733. void LLPreviewGesture::onClickPreview(void* data)
  1734. {
  1735. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1737. if (!self->mPreviewGesture)
  1738. {
  1739. // make temporary gesture
  1740. self->mPreviewGesture = self->createGesture();
  1742. // add a callback
  1743. self->mPreviewGesture->mDoneCallback = onDonePreview;
  1744. self->mPreviewGesture->mCallbackData = self;
  1746. // set the button title
  1747. self->mPreviewBtn->setLabel(self->getString("stop_txt"));
  1749. // play it, and delete when done
  1750. LLGestureManager::instance().playGesture(self->mPreviewGesture);
  1752. self->refresh();
  1753. }
  1754. else
  1755. {
  1756. // Will call onDonePreview() below
  1757. LLGestureManager::instance().stopGesture(self->mPreviewGesture);
  1759. self->refresh();
  1760. }
  1761. }
  1764. // static
  1765. void LLPreviewGesture::onDonePreview(LLMultiGesture* gesture, void* data)
  1766. {
  1767. LLPreviewGesture* self = (LLPreviewGesture*)data;
  1769. self->mPreviewBtn->setLabel(self->getString("preview_txt"));
  1771. delete self->mPreviewGesture;
  1772. self->mPreviewGesture = NULL;
  1774. self->refresh();
  1775. }