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

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

游戏引擎

开发平台：

C++ Builder

llfloatercustomize.cpp：源码内容
  1. /** 
  2.  * @file llfloatercustomize.cpp
  3.  * @brief The customize avatar floater, triggered by "Appearance..."
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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 "llfloatercustomize.h"
  37. #include "llagent.h"
  38. #include "llagentwearables.h"
  39. #include "llappearance.h"
  40. #include "llappearancemgr.h"
  41. #include "llassetstorage.h"
  42. #include "llbutton.h"
  43. #include "llcolorswatch.h"
  44. #include "lldbstrings.h"
  45. #include "llfilepicker.h"
  46. #include "llfloaterreg.h"
  47. #include "llfloaterscriptlimits.h"
  48. #include "llfloatertools.h"
  49. #include "llfocusmgr.h"
  50. #include "llfontgl.h"
  51. #include "llglheaders.h"
  52. #include "llimagejpeg.h"
  53. #include "llinventoryobserver.h"
  54. #include "lllineeditor.h"
  55. #include "llmodaldialog.h"
  56. #include "llmorphview.h"
  57. #include "llnotificationsutil.h"
  58. #include "llradiogroup.h"
  59. #include "llresmgr.h"
  60. #include "llscrollcontainer.h"
  61. #include "llscrollingpanellist.h"
  62. #include "llsidepanelappearance.h"
  63. #include "llsidetray.h"
  64. #include "llsliderctrl.h"
  65. #include "llspinctrl.h"
  66. #include "lltabcontainer.h"
  67. #include "lltextbox.h"
  68. #include "lltexturectrl.h"
  69. #include "lltextureentry.h"
  70. #include "lltoolmgr.h"
  71. #include "lltoolmorph.h"
  72. #include "lltrans.h"
  73. #include "llui.h"
  74. #include "lluictrlfactory.h"
  75. #include "llviewercamera.h"
  76. #include "llviewercontrol.h"
  77. #include "llviewermessage.h"
  78. #include "llviewermenu.h"
  79. #include "llviewertexturelist.h"
  80. #include "llviewerregion.h"
  81. #include "llviewerwindow.h"
  82. #include "llvoavatarself.h"
  83. #include "llwearablelist.h"
  84. #include "imageids.h"
  86. #include "llscrollingpanelparam.h"
  88. using namespace LLVOAvatarDefines;
  90. //*TODO: Translate : The ui xml for this really needs to be integrated with the appearance paramaters
  92. // Globals
  93. LLFloaterCustomize* gFloaterCustomize = NULL;
  95. const F32 PARAM_STEP_TIME_THRESHOLD = 0.25f;
  97. /////////////////////////////////////////////////////////////////////
  98. // LLFloaterCustomizeObserver
  100. class LLFloaterCustomizeObserver : public LLInventoryObserver
  101. {
  102. public:
  103. LLFloaterCustomizeObserver(LLFloaterCustomize* fc) : mFC(fc) {}
  104. virtual ~LLFloaterCustomizeObserver() {}
  105. virtual void changed(U32 mask) { mFC->updateScrollingPanelUI(); }
  106. protected:
  107. LLFloaterCustomize* mFC;
  108. };
  110. ////////////////////////////////////////////////////////////////////////////
  112. // Local Constants 
  114. class LLWearableSaveAsDialog : public LLModalDialog
  115. {
  116. private:
  117. std::string mItemName;
  118. std::string mTempItemName;
  120. boost::signals2::signal<void (const std::string&)> mSaveAsSignal;
  122. public:
  123. LLWearableSaveAsDialog( const LLSD& key )
  124. : LLModalDialog( key ),
  125.   mTempItemName(key.asString())
  126. {
  127. }
  129. BOOL postBuild()
  130. {
  131. getChild<LLUICtrl>("Save")->setCommitCallback(boost::bind(&LLWearableSaveAsDialog::onSave, this ));
  132. getChild<LLUICtrl>("Cancel")->setCommitCallback(boost::bind(&LLWearableSaveAsDialog::onCancel, this ));
  134. childSetTextArg("name ed", "[DESC]", mTempItemName);
  135. return TRUE;
  136. }
  138. void setSaveAsCommit( const boost::signals2::signal<void (const std::string&)>::slot_type& cb )
  139. {
  140. mSaveAsSignal.connect(cb);
  141. }
  143. virtual void onOpen(const LLSD& key)
  144. {
  145. LLLineEditor* edit = getChild<LLLineEditor>("name ed");
  146. if (edit)
  147. {
  148. edit->setFocus(TRUE);
  149. edit->selectAll();
  150. }
  151. }
  153. void onSave()
  154. {
  155. mItemName = childGetValue("name ed").asString();
  156. LLStringUtil::trim(mItemName);
  157. if( !mItemName.empty() )
  158. {
  159. mSaveAsSignal(mItemName);
  160. closeFloater(); // destroys this object
  161. }
  162. }
  164. void onCancel()
  165. {
  166. closeFloater(); // destroys this object
  167. }
  168. };
  170. ////////////////////////////////////////////////////////////////////////////
  172. BOOL edit_wearable_for_teens(EWearableType type)
  173. {
  174. switch(type)
  175. {
  176. case WT_UNDERSHIRT:
  177. case WT_UNDERPANTS:
  178. return FALSE;
  179. default:
  180. return TRUE;
  181. }
  182. }
  184. /////////////////////////////////////////////////////////////////////
  185. // LLPanelWearable
  187. enum ESubpart {
  188. SUBPART_SHAPE_uninit = 0,
  190. SUBPART_SHAPE_HEAD,
  191. SUBPART_SHAPE_EYES,
  192. SUBPART_SHAPE_EARS,
  193. SUBPART_SHAPE_NOSE,
  194. SUBPART_SHAPE_MOUTH,
  195. SUBPART_SHAPE_CHIN,
  196. SUBPART_SHAPE_TORSO,
  197. SUBPART_SHAPE_LEGS,
  198. SUBPART_SHAPE_WHOLE,
  199. SUBPART_SHAPE_DETAIL,
  200. SUBPART_SKIN_COLOR,
  201. SUBPART_SKIN_FACEDETAIL,
  202. SUBPART_SKIN_MAKEUP,
  203. SUBPART_SKIN_BODYDETAIL,
  204. SUBPART_HAIR_COLOR,
  205. SUBPART_HAIR_STYLE,
  206. SUBPART_HAIR_EYEBROWS,
  207. SUBPART_HAIR_FACIAL,
  208. SUBPART_EYES,
  209. SUBPART_SHIRT,
  210. SUBPART_PANTS,
  211. SUBPART_SHOES,
  212. SUBPART_SOCKS,
  213. SUBPART_JACKET,
  214. SUBPART_GLOVES,
  215. SUBPART_UNDERSHIRT,
  216. SUBPART_UNDERPANTS,
  217. SUBPART_SKIRT,
  218. SUBPART_ALPHA,
  219. SUBPART_TATTOO
  220.  };
  222. struct LLSubpart
  223. {
  224. LLSubpart() : mSex( SEX_BOTH ) {}
  226. std::string mButtonName;
  227. std::string mTargetJoint;
  228. std::string mEditGroup;
  229. LLVector3d mTargetOffset;
  230. LLVector3d mCameraOffset;
  231. ESex mSex;
  232. };
  234. ////////////////////////////////////////////////////////////////////////////
  236. class LLPanelWearable : public LLPanel
  237. {
  238. public:
  239. LLPanelWearable( EWearableType type );
  240. virtual ~LLPanelWearable();
  241. void onParentFloaterClosed(); // Parent (i.e. llfloatercustomize floater) was closed
  243. virtual BOOL  postBuild();
  244. virtual void draw();
  245. virtual BOOL isDirty() const; // LLUICtrl
  247. void addSubpart(const std::string& name, ESubpart id, LLSubpart* part );
  248. void addTextureDropTarget( LLVOAvatarDefines::ETextureIndex te, const std::string& name, const LLUUID& default_image_id, BOOL allow_no_texture );
  249. void addInvisibilityCheckbox( LLVOAvatarDefines::ETextureIndex te, const std::string& name );
  250. void addColorSwatch( LLVOAvatarDefines::ETextureIndex te, const std::string& name );
  252. const std::string& getLabel() const  { return LLWearableDictionary::getTypeLabel( mType ); }
  253. EWearableType getType() const  { return mType; }
  254. U32 getIndex() const  { return mIndex; }
  255. LLWearable* getWearable() const { return gAgentWearables.getWearable(mType, mIndex); }
  257. void cleanupIndex();
  259. LLSubpart* getCurrentSubpart() { return mSubpartList[mCurrentSubpart]; }
  260. ESubpart getDefaultSubpart();
  261. void setSubpart( ESubpart subpart );
  262. void switchToDefaultSubpart();
  263. void reset();
  265. void  setWearable(LLWearable* wearable, U32 perm_mask, BOOL is_complete);
  267. void  setUIPermissions(U32 perm_mask, BOOL is_complete);
  269. void hideTextureControls();
  270. bool textureIsInvisible( LLVOAvatarDefines::ETextureIndex te );
  271. void initPreviousTextureList();
  272. void initPreviousTextureListEntry(ETextureIndex te);
  274. virtual void setVisible( BOOL visible );
  276. // Callbacks
  277. static void onBtnSubpart( void* userdata );
  278. static void onBtnTakeOff( void* userdata );
  279. static void onBtnSave( void* userdata );
  281. static void onBtnSaveAs( void* userdata );
  282. void onSaveAsCommit(const std::string& item_name);
  284. static void onBtnRevert( void* userdata );
  285. static void onBtnTakeOffDialog( S32 option, void* userdata );
  286. static void onBtnCreateNew( void* userdata );
  287. static void onTextureCommit( LLUICtrl* ctrl, void* userdata );
  288. static void onInvisibilityCommit( LLUICtrl* ctrl, void* userdata );
  289. static void onColorCommit( LLUICtrl* ctrl, void* userdata );
  290. static void onCommitSexChange( LLUICtrl*, void* userdata );
  291. static bool onSelectAutoWearOption(const LLSD& notification, const LLSD& response);
  292. static void onIndexSet( LLUICtrl*, void* userdata );
  296. private:
  297. EWearableType mType;
  298. U32 mIndex;
  299. bool mCanTakeOff;
  300. typedef std::map<std::string, S32> string_s32_map_t;
  301. string_s32_map_t mTextureList;
  302. string_s32_map_t mInvisibilityList;
  303. string_s32_map_t mColorList;
  305. typedef std::map<S32,LLUUID> s32_uuid_map_t;
  306. s32_uuid_map_t mPreviousTextureList;
  308. std::map<ESubpart, LLSubpart*> mSubpartList;
  309. ESubpart mCurrentSubpart;
  310. };
  312. ////////////////////////////////////////////////////////////////////////////
  314. LLPanelWearable::LLPanelWearable( EWearableType type )
  315. : LLPanel(),
  316.   mType(type),
  317.   mIndex(0),
  318.   mCanTakeOff(false),
  319.   mCurrentSubpart(SUBPART_SHAPE_uninit)
  320. {
  321. static bool registered_dialog = false;
  322. if (!registered_dialog)
  323. {
  324. LLFloaterReg::add("wearable_save_as", "floater_wearable_save_as.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLWearableSaveAsDialog>);
  325. registered_dialog = true;
  326. }
  327. }
  329. void LLPanelWearable::onParentFloaterClosed()
  330. {
  331. // Commit and close all children.
  332. for (string_s32_map_t::const_iterator iter = mColorList.begin();
  333.  iter != mColorList.end(); 
  334.  ++iter)
  335. {
  336. const std::string name = iter->first;
  337. LLColorSwatchCtrl* ctrl = getChild<LLColorSwatchCtrl>(name);
  338. if (ctrl)
  339. {
  340. ctrl->onParentFloaterClosed();
  341. }
  342. }
  343. }
  345. BOOL LLPanelWearable::postBuild()
  346. {
  347. LLAssetType::EType asset_type = LLWearableDictionary::getAssetType( mType );
  348. std::string icon_name = (asset_type == LLAssetType::AT_CLOTHING ?
  349.  "Inv_Clothing" :
  350.  "Inv_Skin" );
  351. childSetValue("icon", icon_name);
  353. childSetAction("Create New", LLPanelWearable::onBtnCreateNew, this );
  355. // If PG, can't take off underclothing or shirt
  356. mCanTakeOff =
  357. LLWearableDictionary::getAssetType( mType ) == LLAssetType::AT_CLOTHING &&
  358. !( gAgent.isTeen() && (mType == WT_UNDERSHIRT || mType == WT_UNDERPANTS) );
  359. childSetVisible("Take Off", mCanTakeOff);
  360. childSetAction("Take Off", LLPanelWearable::onBtnTakeOff, this );
  362. childSetAction("Save",  &LLPanelWearable::onBtnSave, (void*)this );
  364. childSetAction("Save As", &LLPanelWearable::onBtnSaveAs, (void*)this );
  366. childSetAction("Revert", &LLPanelWearable::onBtnRevert, (void*)this );
  368. childSetCommitCallback("index", &LLPanelWearable::onIndexSet, (void*)this );
  370. return TRUE;
  371. }
  373. LLPanelWearable::~LLPanelWearable()
  374. {
  375. std::for_each(mSubpartList.begin(), mSubpartList.end(), DeletePairedPointer());
  377. }
  379. void LLPanelWearable::addSubpart( const std::string& name, ESubpart id, LLSubpart* part )
  380. {
  381. if (!name.empty())
  382. {
  383. childSetAction(name, &LLPanelWearable::onBtnSubpart, (void*)id);
  384. part->mButtonName = name;
  385. }
  386. mSubpartList[id] = part;
  388. }
  390. // static
  391. void LLPanelWearable::onBtnSubpart(void* userdata)
  392. {
  393. LLFloaterCustomize* floater_customize = gFloaterCustomize;
  394. if (!floater_customize) return;
  395. LLPanelWearable* self = floater_customize->getCurrentWearablePanel();
  396. if (!self) return;
  397. ESubpart subpart = (ESubpart) (intptr_t)userdata;
  398. self->setSubpart( subpart );
  399. }
  401. void LLPanelWearable::setSubpart( ESubpart subpart )
  402. {
  403. mCurrentSubpart = subpart;
  405. LLSubpart* part = get_if_there(mSubpartList, (ESubpart)subpart, (LLSubpart*)NULL);
  406. if( part )
  407. {
  408. // Update the thumbnails we display
  409. LLFloaterCustomize::param_map sorted_params;
  410. LLVOAvatar* avatar = gAgent.getAvatarObject();
  411. ESex avatar_sex = avatar->getSex();
  412. LLViewerInventoryItem* item = NULL;
  413. LLWearable* wearable = getWearable();
  414. // MULTI_WEARABLE:
  415. if (wearable)
  416. {
  417. item = (LLViewerInventoryItem*)gInventory.getItem(wearable->getItemID());
  418. }
  419. U32 perm_mask = 0x0;
  420. BOOL is_complete = FALSE;
  421. if(item)
  422. {
  423. perm_mask = item->getPermissions().getMaskOwner();
  424. is_complete = item->isComplete();
  425. }
  426. setUIPermissions(perm_mask, is_complete);
  427. BOOL editable = ((perm_mask & PERM_MODIFY) && is_complete) ? TRUE : FALSE;
  429. for (std::map<ESubpart, LLSubpart*>::iterator iter = mSubpartList.begin();
  430.  iter != mSubpartList.end(); ++iter)
  431. {
  432. LLButton* btn = getChild<LLButton>(iter->second->mButtonName);
  433. if (btn)
  434. {
  435. btn->setVisible(editable);
  436. btn->setToggleState( (subpart == iter->first) );
  437. }
  438. }
  440. if (wearable && editable)
  441. {
  442. for(LLViewerVisualParam* param = (LLViewerVisualParam *)avatar->getFirstVisualParam(); 
  443. param; 
  444. param = (LLViewerVisualParam *)avatar->getNextVisualParam())
  445. {
  446. if (param->getID() == -1
  447. || param->getGroup() != VISUAL_PARAM_GROUP_TWEAKABLE 
  448. || param->getEditGroup() != part->mEditGroup 
  449. || !(param->getSex() & avatar_sex))
  450. {
  451. continue;
  452. }
  454. // negative getDisplayOrder() to make lowest order the highest priority
  455. LLFloaterCustomize::param_map::value_type vt(-param->getDisplayOrder(), LLFloaterCustomize::editable_param(editable, param));
  456. llassert( sorted_params.find(-param->getDisplayOrder()) == sorted_params.end() );  // Check for duplicates
  457. sorted_params.insert(vt);
  458. }
  459. gFloaterCustomize->generateVisualParamHints(NULL, sorted_params, this);
  460. gFloaterCustomize->updateScrollingPanelUI();
  461. } 
  462. else
  463. {
  464. gFloaterCustomize->clearScrollingPanelList();
  465. }
  468. // Update the camera
  469. gMorphView->setCameraTargetJoint( gAgent.getAvatarObject()->getJoint( part->mTargetJoint ) );
  470. gMorphView->setCameraTargetOffset( part->mTargetOffset );
  471. gMorphView->setCameraOffset( part->mCameraOffset );
  472. gMorphView->setCameraDistToDefault();
  473. if (gSavedSettings.getBOOL("AppearanceCameraMovement"))
  474. {
  475. gMorphView->updateCamera();
  476. }
  477. }
  478. }
  480. // static
  481. void LLPanelWearable::onBtnTakeOff( void* userdata )
  482. {
  483. LLPanelWearable* self = (LLPanelWearable*) userdata;
  485. LLWearable* wearable = gAgentWearables.getWearable( self->mType, self->mIndex );
  486. if( !wearable )
  487. {
  488. return;
  489. }
  491. LLAppearanceManager::instance().removeCOFItemLinks(wearable->getItemID(), true);
  492. }
  494. // static
  495. void LLPanelWearable::onBtnSave( void* userdata )
  496. {
  497. LLPanelWearable* self = (LLPanelWearable*) userdata;
  498. gAgentWearables.saveWearable( self->mType, self->mIndex );
  499. if (gFloaterCustomize)
  500. {
  501. gFloaterCustomize->setWearable(self->mType, 
  502.    self->mIndex);
  503. gFloaterCustomize->getCurrentWearablePanel()->reset();
  504. }
  505. }
  507. // static
  508. void LLPanelWearable::onBtnSaveAs( void* userdata )
  509. {
  510. LLPanelWearable* self = (LLPanelWearable*) userdata;
  511. // MULTI_WEARABLE:
  512. LLWearable* wearable = gAgentWearables.getWearable( self->getType(), 0 );
  513. if( wearable )
  514. {
  515. LLWearableSaveAsDialog* save_as_dialog = LLFloaterReg::showTypedInstance<LLWearableSaveAsDialog>("wearable_save_as", LLSD(wearable->getName()), TRUE);
  516. if (save_as_dialog)
  517. {
  518. save_as_dialog->setSaveAsCommit(boost::bind(&LLPanelWearable::onSaveAsCommit, self, _1 ));
  519. }
  520. }
  521. }
  523. void LLPanelWearable::onSaveAsCommit(const std::string& item_name)
  524. {
  525. LLVOAvatar* avatar = gAgent.getAvatarObject();
  526. if( avatar )
  527. {
  528. gAgentWearables.saveWearableAs( mType, mIndex, item_name, FALSE );
  529. }
  530. }
  532. // static
  533. void LLPanelWearable::onBtnRevert( void* userdata )
  534. {
  535. LLPanelWearable* self = (LLPanelWearable*) userdata;
  536. gAgentWearables.revertWearable( self->mType, self->mIndex );
  537. }
  539. // static
  540. void LLPanelWearable::onBtnCreateNew( void* userdata )
  541. {
  542. LLPanelWearable* self = (LLPanelWearable*) userdata;
  543. LLSD payload;
  544. payload["wearable_type"] = (S32)self->getType();
  545. LLNotificationsUtil::add("AutoWearNewClothing", LLSD(), payload, &onSelectAutoWearOption);
  546. }
  548. bool LLPanelWearable::onSelectAutoWearOption(const LLSD& notification, const LLSD& response)
  549. {
  550. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  551. LLVOAvatar* avatar = gAgent.getAvatarObject();
  552. if(avatar)
  553. {
  554. // Create a new wearable in the default folder for the wearable's asset type.
  555. LLWearable* wearable = LLWearableList::instance().createNewWearable( (EWearableType)notification["payload"]["wearable_type"].asInteger() );
  556. LLAssetType::EType asset_type = wearable->getAssetType();
  558. LLUUID folder_id;
  559. // regular UI, items get created in normal folder
  560. folder_id = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(asset_type));
  562. // Only auto wear the new item if the AutoWearNewClothing checkbox is selected.
  563. LLPointer<LLInventoryCallback> cb = option == 0 ? 
  564. new WearOnAvatarCallback : NULL;
  565. create_inventory_item(gAgent.getID(), gAgent.getSessionID(),
  566. folder_id, wearable->getTransactionID(), wearable->getName(), wearable->getDescription(),
  567. asset_type, LLInventoryType::IT_WEARABLE, wearable->getType(),
  568. wearable->getPermissions().getMaskNextOwner(), cb);
  569. }
  570. return false;
  571. }
  573. // static
  574. void LLPanelWearable::onIndexSet( LLUICtrl*, void* userdata )
  575. {
  576. LLPanelWearable* self = (LLPanelWearable*) userdata;
  577. U32 new_index = self->childGetValue("index").asInteger();
  578. if (self->mIndex != new_index)
  579. {
  580. self->mIndex = new_index;
  581. llinfos << "type " << self->mType << " index " << self->mIndex << " wearable ptr: " << self->getWearable() << llendl;
  582. }
  583. }
  585. bool LLPanelWearable::textureIsInvisible( LLVOAvatarDefines::ETextureIndex te )
  586. {
  587. if( getWearable() )
  588. {
  589. LLViewerTexture* curr_image = getWearable()->getLocalTextureObject(te)->getImage();
  590. return (curr_image && curr_image->getID() == IMG_INVISIBLE);
  591. }
  592. else
  593. return false;
  594. }
  596. void LLPanelWearable::addInvisibilityCheckbox( LLVOAvatarDefines::ETextureIndex te, const std::string& name )
  597. {
  598. childSetCommitCallback(name, LLPanelWearable::onInvisibilityCommit, this);
  600. mInvisibilityList[name] = te;
  601. }
  603. // static
  604. void LLPanelWearable::onInvisibilityCommit( LLUICtrl* ctrl, void* userdata )
  605. {
  606. LLPanelWearable* self = (LLPanelWearable*) userdata;
  607. LLCheckBoxCtrl* checkbox_ctrl = (LLCheckBoxCtrl*) ctrl;
  608. llinfos << "onInvisibilityCommit, self " << self << " checkbox_ctrl " << checkbox_ctrl << llendl;
  609. LLVOAvatarSelf *avatar = gAgent.getAvatarObject();
  611. ETextureIndex te = (ETextureIndex)(self->mInvisibilityList[ctrl->getName()]);
  613. bool new_invis_state = checkbox_ctrl->get();
  614. if (new_invis_state)
  615. {
  616. LLViewerFetchedTexture* image = LLViewerTextureManager::getFetchedTexture( IMG_INVISIBLE );
  617. LLLocalTextureObject *lto = self->getWearable()->getLocalTextureObject(te);
  618. self->mPreviousTextureList[(S32)te] = lto->getID();
  619. U32 index = gAgentWearables.getWearableIndex(self->getWearable());
  620. avatar->setLocalTexture(te,image,FALSE,index);
  621. avatar->wearableUpdated(self->getWearable()->getType(), FALSE);
  622. }
  623. else
  624. {
  625. // Try to restore previous texture, if any.
  626. LLUUID prev_id = self->mPreviousTextureList[(S32)te];
  627. if (prev_id.isNull() || (prev_id == IMG_INVISIBLE))
  628. {
  629. prev_id = LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) );
  630. }
  631. if (prev_id.notNull())
  632. {
  633. LLViewerFetchedTexture* image = LLViewerTextureManager::getFetchedTexture( prev_id );
  634. U32 index = gAgentWearables.getWearableIndex(self->getWearable());
  635. avatar->setLocalTexture(te,image,FALSE,index);
  636. avatar->wearableUpdated(self->getWearable()->getType(), FALSE);
  637. }
  639. }
  640. }
  642. void LLPanelWearable::addColorSwatch( LLVOAvatarDefines::ETextureIndex te, const std::string& name )
  643. {
  644. childSetCommitCallback(name, LLPanelWearable::onColorCommit, this);
  645. mColorList[name] = te;
  646. }
  648. // static
  649. void LLPanelWearable::onColorCommit( LLUICtrl* ctrl, void* userdata )
  650. {
  651. LLPanelWearable* self = (LLPanelWearable*) userdata;
  652. LLColorSwatchCtrl* color_ctrl = (LLColorSwatchCtrl*) ctrl;
  654. ETextureIndex te = (ETextureIndex)(self->mColorList[ctrl->getName()]);
  655. LLVOAvatarSelf *avatar = gAgent.getAvatarObject();
  657. LLColor4 old_color = self->getWearable()->getClothesColor(te);
  658. const LLColor4& new_color = color_ctrl->get();
  659. if( old_color != new_color )
  660. {
  661. // Set the new version
  662. self->getWearable()->setClothesColor( te, new_color, TRUE );
  664. LLVisualParamHint::requestHintUpdates();
  665. avatar->wearableUpdated(self->getWearable()->getType(), FALSE);
  666. }
  667. }
  669. void LLPanelWearable::initPreviousTextureList()
  670. {
  671. initPreviousTextureListEntry(TEX_LOWER_ALPHA);
  672. initPreviousTextureListEntry(TEX_UPPER_ALPHA);
  673. initPreviousTextureListEntry(TEX_HEAD_ALPHA);
  674. initPreviousTextureListEntry(TEX_EYES_ALPHA);
  675. initPreviousTextureListEntry(TEX_LOWER_ALPHA);
  676. }
  678. void LLPanelWearable::initPreviousTextureListEntry(ETextureIndex te)
  679. {
  680. LLLocalTextureObject *lto = getWearable()->getLocalTextureObject(te);
  681. if (lto)
  682. {
  683. mPreviousTextureList[te] = lto->getID();
  684. }
  685. }
  687. void LLPanelWearable::addTextureDropTarget( ETextureIndex te, const std::string& name,
  688. const LLUUID& default_image_id, BOOL allow_no_texture )
  689. {
  690. childSetCommitCallback(name, LLPanelWearable::onTextureCommit, this);
  691. LLTextureCtrl* texture_ctrl = getChild<LLTextureCtrl>(name);
  692. if (texture_ctrl)
  693. {
  694. texture_ctrl->setDefaultImageAssetID(default_image_id);
  695. texture_ctrl->setAllowNoTexture( allow_no_texture );
  696. // Don't allow (no copy) or (no transfer) textures to be selected.
  697. texture_ctrl->setImmediateFilterPermMask(PERM_NONE);//PERM_COPY | PERM_TRANSFER);
  698. texture_ctrl->setNonImmediateFilterPermMask(PERM_NONE);//PERM_COPY | PERM_TRANSFER);
  699. }
  700. mTextureList[name] = te;
  701. if (getWearable())
  702. {
  703. LLLocalTextureObject *lto = getWearable()->getLocalTextureObject(te);
  704. if (lto)
  705. {
  706. mPreviousTextureList[te] = lto->getID();
  707. }
  708. }
  709. }
  711. // static
  712. void LLPanelWearable::onTextureCommit( LLUICtrl* ctrl, void* userdata )
  713. {
  714. LLPanelWearable* self = (LLPanelWearable*) userdata;
  715. LLTextureCtrl* texture_ctrl = (LLTextureCtrl*) ctrl;
  717. ETextureIndex te = (ETextureIndex)(self->mTextureList[ctrl->getName()]);
  719. // Set the new version
  720. LLViewerFetchedTexture* image = LLViewerTextureManager::getFetchedTexture( texture_ctrl->getImageAssetID() );
  721. if( image->getID().isNull() )
  722. {
  723. image = LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT_AVATAR);
  724. }
  725. if (self->getWearable())
  726. {
  727. LLVOAvatarSelf *avatar = gAgent.getAvatarObject();
  728. U32 index = gAgentWearables.getWearableIndex(self->getWearable());
  729. avatar->setLocalTexture(te,image,FALSE,index);
  730. avatar->wearableUpdated(self->getWearable()->getType(), FALSE);
  731. }
  732. if (image->getID() != IMG_INVISIBLE)
  733. {
  734. self->mPreviousTextureList[te] = image->getID();
  735. }
  736. }
  739. ESubpart LLPanelWearable::getDefaultSubpart()
  740. {
  741. switch( mType )
  742. {
  743. case WT_SHAPE: return SUBPART_SHAPE_WHOLE;
  744. case WT_SKIN: return SUBPART_SKIN_COLOR;
  745. case WT_HAIR: return SUBPART_HAIR_COLOR;
  746. case WT_EYES: return SUBPART_EYES;
  747. case WT_SHIRT: return SUBPART_SHIRT;
  748. case WT_PANTS: return SUBPART_PANTS;
  749. case WT_SHOES: return SUBPART_SHOES;
  750. case WT_SOCKS: return SUBPART_SOCKS;
  751. case WT_JACKET: return SUBPART_JACKET;
  752. case WT_GLOVES: return SUBPART_GLOVES;
  753. case WT_UNDERSHIRT: return SUBPART_UNDERSHIRT;
  754. case WT_UNDERPANTS: return SUBPART_UNDERPANTS;
  755. case WT_SKIRT: return SUBPART_SKIRT;
  756. case WT_ALPHA: return SUBPART_ALPHA;
  757. case WT_TATTOO: return SUBPART_TATTOO;
  759. default: llassert(0); return SUBPART_SHAPE_WHOLE;
  760. }
  761. }
  764. void LLPanelWearable::draw()
  765. {
  766. if( gFloaterCustomize->isMinimized() )
  767. {
  768. return;
  769. }
  771. LLVOAvatar* avatar = gAgent.getAvatarObject();
  772. if( !avatar )
  773. {
  774. return;
  775. }
  777. cleanupIndex();
  778. BOOL has_wearable = (getWearable() != NULL );
  779. BOOL is_dirty = isDirty();
  780. BOOL is_modifiable = FALSE;
  781. BOOL is_copyable = FALSE;
  782. BOOL is_complete = FALSE;
  783. LLViewerInventoryItem* item;
  785. item = (LLViewerInventoryItem*)gAgentWearables.getWearableInventoryItem(mType, mIndex);
  786. if(item)
  787. {
  788. const LLPermissions& perm = item->getPermissions();
  789. is_modifiable = perm.allowModifyBy(gAgent.getID(), gAgent.getGroupID());
  790. is_copyable = perm.allowCopyBy(gAgent.getID(), gAgent.getGroupID());
  791. is_complete = item->isComplete();
  792. }
  794. childSetEnabled("Save", is_modifiable && is_complete && has_wearable && is_dirty);
  795. childSetEnabled("Save As", is_copyable && is_complete && has_wearable);
  796. childSetEnabled("Revert", has_wearable && is_dirty );
  797. childSetEnabled("Take Off",  has_wearable );
  798. childSetVisible("Take Off", mCanTakeOff && has_wearable  );
  799. childSetVisible("Create New", !has_wearable );
  801. childSetVisible("not worn instructions",  !has_wearable );
  802. childSetVisible("no modify instructions",  has_wearable && !is_modifiable);
  804. for (std::map<ESubpart, LLSubpart*>::iterator iter = mSubpartList.begin();
  805.  iter != mSubpartList.end(); ++iter)
  806. {
  807. if( has_wearable && is_complete && is_modifiable )
  808. {
  809. childSetEnabled(iter->second->mButtonName, iter->second->mSex & avatar->getSex() );
  810. }
  811. else
  812. {
  813. childSetEnabled(iter->second->mButtonName, FALSE );
  814. }
  815. }
  817. childSetVisible("square", !is_modifiable);
  819. childSetVisible("title", FALSE);
  820. childSetVisible("title_no_modify", FALSE);
  821. childSetVisible("title_not_worn", FALSE);
  822. childSetVisible("title_loading", FALSE);
  824. childSetVisible("path", FALSE);
  825. LLSpinCtrl* spin_ctrl = findChild<LLSpinCtrl>("index",FALSE);
  826. if (spin_ctrl)
  827. {
  828. spin_ctrl->setVisible(FALSE);
  829. }
  831. if(has_wearable && !is_modifiable)
  832. {
  833. childSetVisible("title_no_modify", TRUE);
  834. childSetTextArg("title_no_modify", "[DESC]", std::string(LLWearableDictionary::getTypeLabel( mType )));
  836. hideTextureControls();
  837. }
  838. else if(has_wearable && !is_complete)
  839. {
  840. childSetVisible("title_loading", TRUE);
  841. childSetTextArg("title_loading", "[DESC]", std::string(LLWearableDictionary::getTypeLabel( mType )));
  843. std::string path;
  844. const LLUUID& item_id = gAgentWearables.getWearableItemID( getWearable()->getType(), mIndex );
  845. llassert_always(item_id.notNull()); // MULTI_WEARABLE:
  846. gInventory.appendPath(item_id, path);
  847. childSetVisible("path", TRUE);
  848. childSetTextArg("path", "[PATH]", path);
  849. U32 count = gAgentWearables.getWearableCount( getWearable()->getType() );
  850. if ((count>0) && spin_ctrl)
  851. {
  852. spin_ctrl->setMinValue((F32)0);
  853. spin_ctrl->setMaxValue((F32)(count-1));
  854. spin_ctrl->setValue( (F32)mIndex );
  855. spin_ctrl->setVisible(TRUE);
  856. }
  858. hideTextureControls();
  859. }
  860. else if(has_wearable && is_modifiable)
  861. {
  862. childSetVisible("title", TRUE);
  863. childSetTextArg("title", "[DESC]", getWearable()->getName() );
  865. std::string path;
  866. const LLUUID& item_id = gAgentWearables.getWearableItemID( getWearable()->getType(), mIndex );
  867. llassert_always(item_id.notNull()); // MULTI_WEARABLE:
  868. gInventory.appendPath(item_id, path);
  869. childSetVisible("path", TRUE);
  870. childSetTextArg("path", "[PATH]", path);
  871. U32 count = gAgentWearables.getWearableCount( getWearable()->getType() );
  872. if ((count>0) && spin_ctrl)
  873. {
  874. spin_ctrl->setMinValue((F32)0);
  875. spin_ctrl->setMaxValue((F32)(count-1));
  876. spin_ctrl->setValue( (F32)mIndex );
  877. spin_ctrl->setVisible(TRUE);
  878. }
  880. for( string_s32_map_t::iterator iter = mTextureList.begin();
  881.  iter != mTextureList.end(); ++iter )
  882. {
  883. std::string name = iter->first;
  884. LLTextureCtrl* texture_ctrl = getChild<LLTextureCtrl>(name);
  885. S32 te_index = iter->second;
  886. childSetVisible(name, is_copyable && is_modifiable && is_complete );
  887. if (texture_ctrl)
  888. {
  889. LLLocalTextureObject *lto = getWearable()->getLocalTextureObject(te_index);
  891. LLUUID new_id;
  893. if( lto && (lto->getID() != IMG_DEFAULT_AVATAR) )
  894. {
  895. new_id = lto->getID();
  896. }
  897. else
  898. {
  899. new_id = LLUUID::null;
  900. }
  902. LLUUID old_id = texture_ctrl->getImageAssetID();
  904. if (old_id != new_id)
  905. {
  906. // texture has changed, close the floater to avoid DEV-22461
  907. texture_ctrl->closeDependentFloater();
  908. }
  910. texture_ctrl->setImageAssetID(new_id);
  911. }
  912. }
  914. for( string_s32_map_t::iterator iter = mColorList.begin();
  915.  iter != mColorList.end(); ++iter )
  916. {
  917. std::string name = iter->first;
  918. S32 te_index = iter->second;
  919. childSetVisible(name, is_modifiable && is_complete );
  920. childSetEnabled(name, is_modifiable && is_complete );
  921. LLColorSwatchCtrl* ctrl = getChild<LLColorSwatchCtrl>(name);
  922. if (ctrl)
  923. {
  924. ctrl->set(getWearable()->getClothesColor( (ETextureIndex)te_index ) );
  925. }
  926. }
  928. for( string_s32_map_t::iterator iter = mInvisibilityList.begin();
  929.  iter != mInvisibilityList.end(); ++iter )
  930. {
  931. std::string name = iter->first;
  932. LLVOAvatarDefines::ETextureIndex te = (LLVOAvatarDefines::ETextureIndex)iter->second;
  933. childSetVisible(name, is_copyable && is_modifiable && is_complete );
  934. childSetEnabled(name, is_copyable && is_modifiable && is_complete );
  935. LLCheckBoxCtrl* ctrl = getChild<LLCheckBoxCtrl>(name);
  936. if (ctrl)
  937. {
  938. ctrl->set(textureIsInvisible(te));
  939. }
  940. }
  942. }
  943. else
  944. {
  945. childSetVisible("title_not_worn", TRUE);
  946. childSetTextArg("title_not_worn", "[DESC]", std::string(LLWearableDictionary::getTypeLabel( mType )));
  948. hideTextureControls();
  949. }
  951. childSetVisible("icon", has_wearable && is_modifiable);
  953. LLPanel::draw();
  954. }
  956. void LLPanelWearable::hideTextureControls()
  957. {
  958. for( string_s32_map_t::iterator iter = mTextureList.begin();
  959.  iter != mTextureList.end(); ++iter )
  960. {
  961. childSetVisible(iter->first, FALSE );
  962. }
  963. for( string_s32_map_t::iterator iter = mColorList.begin();
  964.  iter != mColorList.end(); ++iter )
  965. {
  966. childSetVisible(iter->first, FALSE );
  967. }
  968. for( string_s32_map_t::iterator iter = mInvisibilityList.begin();
  969.  iter != mInvisibilityList.end(); ++iter )
  970. {
  971. childSetVisible(iter->first, FALSE );
  972. }
  973. }
  975. void LLPanelWearable::setWearable(LLWearable* wearable, U32 perm_mask, BOOL is_complete)
  976. {
  977. if( wearable )
  978. {
  979. setUIPermissions(perm_mask, is_complete);
  980. if (wearable->getType() == WT_ALPHA)
  981. {
  982. initPreviousTextureList();
  983. }
  984. }
  985. }
  987. // Fix mIndex in case clothing has disappeared from gAgentWearables since it was last set.
  988. void LLPanelWearable::cleanupIndex()
  989. {
  990. U32 count = gAgentWearables.getWearableCount(mType);
  991. if ((count > 0) && (mIndex >= count))
  992. {
  993. mIndex = count-1;
  994. }
  995. }
  997. void LLPanelWearable::switchToDefaultSubpart()
  998. {
  999. setSubpart( getDefaultSubpart() );
  1000. }
  1002. void LLPanelWearable::reset()
  1003. {
  1004. setSubpart(mCurrentSubpart);
  1005. }
  1007. void LLPanelWearable::setVisible(BOOL visible)
  1008. {
  1009. LLPanel::setVisible( visible );
  1010. if( !visible )
  1011. {
  1012. for( string_s32_map_t::iterator iter = mColorList.begin();
  1013.  iter != mColorList.end(); ++iter )
  1014. {
  1015. // this forces any open color pickers to cancel their selection
  1016. childSetEnabled(iter->first, FALSE );
  1017. }
  1018. }
  1019. }
  1021. BOOL LLPanelWearable::isDirty() const
  1022. {
  1023. if( !getWearable() )
  1024. {
  1025. return FALSE;
  1026. }
  1028. if( getWearable()->isDirty() )
  1029. {
  1030. return TRUE;
  1031. }
  1033. return FALSE;
  1034. }
  1036. // static
  1037. void LLPanelWearable::onCommitSexChange( LLUICtrl*, void* userdata )
  1038. {
  1039. LLPanelWearable* self = (LLPanelWearable*) userdata;
  1041. LLVOAvatar* avatar = gAgent.getAvatarObject();
  1042. if (!avatar)
  1043. {
  1044. return;
  1045. }
  1047. if( !gAgentWearables.isWearableModifiable(self->mType, self->mIndex))
  1048. {
  1049. return;
  1050. }
  1052. ESex new_sex = gSavedSettings.getU32("AvatarSex") ? SEX_MALE : SEX_FEMALE;
  1054. LLViewerVisualParam* param = (LLViewerVisualParam*)avatar->getVisualParam( "male" );
  1055. if( !param )
  1056. {
  1057. return;
  1058. }
  1060. if (self->getWearable())
  1061. {
  1062. self->getWearable()->setVisualParamWeight(param->getID(), (new_sex==SEX_MALE), FALSE);
  1063. }
  1064. param->setWeight( (new_sex == SEX_MALE), FALSE );
  1066. avatar->updateSexDependentLayerSets( FALSE );
  1068. avatar->updateVisualParams();
  1070. gFloaterCustomize->clearScrollingPanelList();
  1072. // Assumes that we're in the "Shape" Panel.
  1073. self->setSubpart( SUBPART_SHAPE_WHOLE );
  1074. }
  1076. void LLPanelWearable::setUIPermissions(U32 perm_mask, BOOL is_complete)
  1077. {
  1078. BOOL is_copyable = (perm_mask & PERM_COPY) ? TRUE : FALSE;
  1079. BOOL is_modifiable = (perm_mask & PERM_MODIFY) ? TRUE : FALSE;
  1081. childSetEnabled("Save", is_modifiable && is_complete);
  1082. childSetEnabled("Save As", is_copyable && is_complete);
  1083. childSetEnabled("sex radio", is_modifiable && is_complete);
  1084. for( string_s32_map_t::iterator iter = mTextureList.begin();
  1085.  iter != mTextureList.end(); ++iter )
  1086. {
  1087. childSetVisible(iter->first, is_copyable && is_modifiable && is_complete );
  1088. }
  1089. for( string_s32_map_t::iterator iter = mColorList.begin();
  1090.  iter != mColorList.end(); ++iter )
  1091. {
  1092. childSetVisible(iter->first, is_modifiable && is_complete );
  1093. }
  1094. for( string_s32_map_t::iterator iter = mInvisibilityList.begin();
  1095.  iter != mInvisibilityList.end(); ++iter )
  1096. {
  1097. childSetVisible(iter->first, is_copyable && is_modifiable && is_complete );
  1098. }
  1099. }
  1101. /////////////////////////////////////////////////////////////////////
  1102. // LLFloaterCustomize
  1104. struct WearablePanelData
  1105. {
  1106. const char* mPanelName;
  1107. EWearableType mType;
  1108. LLFloaterCustomize* mFloater;
  1109. } wearable_panel_data[] = {
  1110. { "Shape", WT_SHAPE, NULL },
  1111. { "Skin", WT_SKIN, NULL },
  1112. { "Hair", WT_HAIR, NULL },
  1113. { "Eyes", WT_EYES, NULL },
  1114. { "Shirt", WT_SHIRT, NULL },
  1115. { "Pants", WT_PANTS, NULL },
  1116. { "Shoes", WT_SHOES, NULL },
  1117. { "Socks", WT_SOCKS, NULL },
  1118. { "Jacket", WT_JACKET, NULL },
  1119. { "Gloves", WT_GLOVES, NULL },
  1120. { "Undershirt", WT_UNDERSHIRT, NULL },
  1121. { "Underpants", WT_UNDERPANTS, NULL },
  1122. { "Skirt", WT_SKIRT, NULL },
  1123. { "Alpha", WT_ALPHA, NULL },
  1124. { "Tattoo", WT_TATTOO, NULL }
  1125. };
  1127. static EWearableType get_wearable_type_from_panel_name(const std::string& name)
  1128. {
  1129. for (S32 i=0; i<LL_ARRAY_SIZE(wearable_panel_data); i++)
  1130. {
  1131. if (name == wearable_panel_data[i].mPanelName)
  1132. return wearable_panel_data[i].mType;
  1133. }
  1134. return WT_INVALID;
  1135. }
  1137. LLFloaterCustomize::LLFloaterCustomize()
  1138. : LLFloater(LLSD()),
  1139. mCurrentWearableType( WT_SHIRT ),
  1140. mScrollingPanelList( NULL ),
  1141. mInventoryObserver(NULL)
  1142. {
  1143. gSavedSettings.setU32("AvatarSex", (gAgent.getAvatarObject()->getSex() == SEX_MALE) );
  1145. mResetParams = new LLVisualParamReset();
  1147. // create the observer which will watch for matching incoming inventory
  1148. mInventoryObserver = new LLFloaterCustomizeObserver(this);
  1149. gInventory.addObserver(mInventoryObserver);
  1151. for (S32 i=0; i<LL_ARRAY_SIZE(wearable_panel_data); i++)
  1152. {
  1153. wearable_panel_data[i].mFloater = this;
  1154. mFactoryMap[wearable_panel_data[i].mPanelName] = LLCallbackMap(createWearablePanel, (void*)(&wearable_panel_data[i]) );
  1155. }
  1157. LLUICtrlFactory::getInstance()->buildFloater(this, "floater_customize.xml", NULL);
  1158. }
  1160. BOOL LLFloaterCustomize::postBuild()
  1161. {
  1162. childSetAction("Ok", LLFloaterCustomize::onBtnOk, (void*)this);
  1163. childSetAction("make_outfit_btn", LLFloaterCustomize::onBtnMakeOutfit, (void*)this);
  1165. // note: on region change this will not be re checked, should not matter on Agni as
  1166. // 99% of the time all regions will return the same caps. In case of an erroneous setting
  1167. // to enabled the floater will just throw an error when trying to get it's cap
  1168. std::string url = gAgent.getRegion()->getCapability("AttachmentResources");
  1169. if (!url.empty())
  1170. {
  1171. childSetAction("script_info", LLFloaterCustomize::onBtnScriptInfo, (void*)this);
  1172. }
  1173. else
  1174. {
  1175. LLButton* script_info_button = getChild<LLButton>("script_info");
  1176. if(script_info_button)
  1177. {
  1178. script_info_button->setVisible(false);
  1179. }
  1180. }
  1182. getChild<LLButton>("Cancel")->setClickedCallback(boost::bind(LLFloater::onClickClose, (LLFloater*)this));
  1184. // Wearable panels
  1185. initWearablePanels();
  1187. // Tab container
  1188. LLTabContainer* tab_container = getChild<LLTabContainer>("customize tab container");
  1189. tab_container->setCommitCallback(boost::bind(&LLFloaterCustomize::onTabChanged, this, _2));
  1190. tab_container->setValidateCallback(boost::bind(&LLFloaterCustomize::onTabPrecommit, this, _1, _2));
  1192. // Remove underwear panels for teens
  1193. if (gAgent.isTeen())
  1194. {
  1195. LLTabContainer* tab_container = getChild<LLTabContainer>("customize tab container");
  1196. if (tab_container)
  1197. {
  1198. LLPanel* panel;
  1199. panel = tab_container->getPanelByName("Undershirt");
  1200. if (panel) tab_container->removeTabPanel(panel);
  1201. panel = tab_container->getPanelByName("Underpants");
  1202. if (panel) tab_container->removeTabPanel(panel);
  1203. }
  1204. }
  1206. mScrollingPanelList = getChild<LLScrollingPanelList>("panel_list");
  1208. return TRUE;
  1209. }
  1211. void LLFloaterCustomize::openFloater()
  1212. {
  1213. LLFloater::openFloater();
  1214. // setCurrentWearableType depends on gFloaterCustomize being defined and therefore must be called after the constructor. - Nyx
  1215. EWearableType type = WT_SHAPE;
  1216. for(S32 i = 0; i < WT_COUNT; i++)
  1217. {
  1218. if( mWearablePanelList[i]
  1219. && mWearablePanelList[i]->isDirty() )
  1220. {
  1221. type = (EWearableType) i;
  1222. }
  1223. }
  1224. setCurrentWearableType(type, true);
  1225. }
  1227. ////////////////////////////////////////////////////////////////////////////
  1229. void LLFloaterCustomize::setCurrentWearableType( EWearableType type, bool force_change )
  1230. {
  1231. if( mCurrentWearableType != type  || force_change)
  1232. {
  1233. mCurrentWearableType = type; 
  1235. S32 type_int = (S32)type;
  1236. if( mWearablePanelList[type_int])
  1237. {
  1238. std::string panelname = mWearablePanelList[type_int]->getName();
  1239. childShowTab("customize tab container", panelname);
  1240. switchToDefaultSubpart();
  1241. }
  1242. }
  1243. }
  1245. // static
  1246. void LLFloaterCustomize::onBtnOk( void* userdata )
  1247. {
  1248. LLFloaterCustomize* floater = (LLFloaterCustomize*) userdata;
  1249. gAgentWearables.saveAllWearables();
  1251. gFloaterView->sendChildToBack(floater);
  1252. handle_reset_view();  // Calls askToSaveIfDirty
  1253. }
  1256. void LLFloaterCustomize::onBtnMakeOutfit( void* userdata )
  1257. {
  1258. LLSidepanelAppearance* panel_appearance =
  1259. dynamic_cast<LLSidepanelAppearance *>(LLSideTray::getInstance()->getPanel("sidepanel_appearance"));
  1260. if (panel_appearance)
  1261. {
  1262. panel_appearance->onNewOutfitButtonClicked();
  1263. }
  1264. }
  1266. void LLFloaterCustomize::onBtnScriptInfo( void* userdata )
  1267. {
  1268. LLFloaterReg::showInstance("script_limits");
  1269. }
  1271. ////////////////////////////////////////////////////////////////////////////
  1273. // static
  1274. void* LLFloaterCustomize::createWearablePanel(void* userdata)
  1275. {
  1276. WearablePanelData* data = (WearablePanelData*)userdata;
  1277. EWearableType type = data->mType;
  1278. LLPanelWearable* panel;
  1279. if ((gAgent.isTeen() && !edit_wearable_for_teens(data->mType) ))
  1280. {
  1281. panel = NULL;
  1282. }
  1283. else
  1284. {
  1285. panel = new LLPanelWearable( type );
  1286. }
  1287. data->mFloater->mWearablePanelList[type] = panel;
  1288. return panel;
  1289. }
  1291. void LLFloaterCustomize::initWearablePanels()
  1292. {
  1293. LLSubpart* part;
  1295. /////////////////////////////////////////
  1296. // Shape
  1297. LLPanelWearable* panel = mWearablePanelList[ WT_SHAPE ];
  1299. // body
  1300. part = new LLSubpart();
  1301. part->mTargetJoint = "mPelvis";
  1302. part->mEditGroup = "shape_body";
  1303. part->mTargetOffset.setVec(0.f, 0.f, 0.1f);
  1304. part->mCameraOffset.setVec(-2.5f, 0.5f, 0.8f);
  1305. panel->addSubpart( "Body", SUBPART_SHAPE_WHOLE, part );
  1307. // head supparts
  1308. part = new LLSubpart();
  1309. part->mTargetJoint = "mHead";
  1310. part->mEditGroup = "shape_head";
  1311. part->mTargetOffset.setVec(0.f, 0.f, 0.05f );
  1312. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f );
  1313. panel->addSubpart( "Head", SUBPART_SHAPE_HEAD, part );
  1315. part = new LLSubpart();
  1316. part->mTargetJoint = "mHead";
  1317. part->mEditGroup = "shape_eyes";
  1318. part->mTargetOffset.setVec(0.f, 0.f, 0.05f );
  1319. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f );
  1320. panel->addSubpart( "Eyes", SUBPART_SHAPE_EYES, part );
  1322. part = new LLSubpart();
  1323. part->mTargetJoint = "mHead";
  1324. part->mEditGroup = "shape_ears";
  1325. part->mTargetOffset.setVec(0.f, 0.f, 0.05f );
  1326. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f );
  1327. panel->addSubpart( "Ears", SUBPART_SHAPE_EARS, part );
  1329. part = new LLSubpart();
  1330. part->mTargetJoint = "mHead";
  1331. part->mEditGroup = "shape_nose";
  1332. part->mTargetOffset.setVec(0.f, 0.f, 0.05f );
  1333. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f );
  1334. panel->addSubpart( "Nose", SUBPART_SHAPE_NOSE, part );
  1337. part = new LLSubpart();
  1338. part->mTargetJoint = "mHead";
  1339. part->mEditGroup = "shape_mouth";
  1340. part->mTargetOffset.setVec(0.f, 0.f, 0.05f );
  1341. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f );
  1342. panel->addSubpart( "Mouth", SUBPART_SHAPE_MOUTH, part );
  1345. part = new LLSubpart();
  1346. part->mTargetJoint = "mHead";
  1347. part->mEditGroup = "shape_chin";
  1348. part->mTargetOffset.setVec(0.f, 0.f, 0.05f );
  1349. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f );
  1350. panel->addSubpart( "Chin", SUBPART_SHAPE_CHIN, part );
  1352. // torso
  1353. part = new LLSubpart();
  1354. part->mTargetJoint = "mTorso";
  1355. part->mEditGroup = "shape_torso";
  1356. part->mTargetOffset.setVec(0.f, 0.f, 0.3f);
  1357. part->mCameraOffset.setVec(-1.f, 0.15f, 0.3f);
  1358. panel->addSubpart( "Torso", SUBPART_SHAPE_TORSO, part );
  1360. // legs
  1361. part = new LLSubpart();
  1362. part->mTargetJoint = "mPelvis";
  1363. part->mEditGroup = "shape_legs";
  1364. part->mTargetOffset.setVec(0.f, 0.f, -0.5f);
  1365. part->mCameraOffset.setVec(-1.6f, 0.15f, -0.5f);
  1366. panel->addSubpart( "Legs", SUBPART_SHAPE_LEGS, part );
  1368. panel->childSetCommitCallback("sex radio", LLPanelWearable::onCommitSexChange, panel);
  1370. /////////////////////////////////////////
  1371. // Skin
  1372. panel = mWearablePanelList[ WT_SKIN ];
  1374. part = new LLSubpart();
  1375. part->mTargetJoint = "mHead";
  1376. part->mEditGroup = "skin_color";
  1377. part->mTargetOffset.setVec(0.f, 0.f, 0.05f);
  1378. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f);
  1379. panel->addSubpart( "Skin Color", SUBPART_SKIN_COLOR, part );
  1381. part = new LLSubpart();
  1382. part->mTargetJoint = "mHead";
  1383. part->mEditGroup = "skin_facedetail";
  1384. part->mTargetOffset.setVec(0.f, 0.f, 0.05f);
  1385. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f);
  1386. panel->addSubpart( "Face Detail", SUBPART_SKIN_FACEDETAIL, part );
  1388. part = new LLSubpart();
  1389. part->mTargetJoint = "mHead";
  1390. part->mEditGroup = "skin_makeup";
  1391. part->mTargetOffset.setVec(0.f, 0.f, 0.05f);
  1392. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f);
  1393. panel->addSubpart( "Makeup", SUBPART_SKIN_MAKEUP, part );
  1395. part = new LLSubpart();
  1396. part->mTargetJoint = "mPelvis";
  1397. part->mEditGroup = "skin_bodydetail";
  1398. part->mTargetOffset.setVec(0.f, 0.f, -0.2f);
  1399. part->mCameraOffset.setVec(-2.5f, 0.5f, 0.5f);
  1400. panel->addSubpart( "Body Detail", SUBPART_SKIN_BODYDETAIL, part );
  1402. panel->addTextureDropTarget( TEX_HEAD_BODYPAINT,  "Head Tattoos",  LLUUID::null, TRUE );
  1403. panel->addTextureDropTarget( TEX_UPPER_BODYPAINT, "Upper Tattoos",  LLUUID::null, TRUE );
  1404. panel->addTextureDropTarget( TEX_LOWER_BODYPAINT, "Lower Tattoos",  LLUUID::null, TRUE );
  1406. /////////////////////////////////////////
  1407. // Hair
  1408. panel = mWearablePanelList[ WT_HAIR ];
  1410. part = new LLSubpart();
  1411. part->mTargetJoint = "mHead";
  1412. part->mEditGroup = "hair_color";
  1413. part->mTargetOffset.setVec(0.f, 0.f, 0.10f);
  1414. part->mCameraOffset.setVec(-0.4f, 0.05f, 0.10f);
  1415. panel->addSubpart( "Color", SUBPART_HAIR_COLOR, part );
  1417. part = new LLSubpart();
  1418. part->mTargetJoint = "mHead";
  1419. part->mEditGroup = "hair_style";
  1420. part->mTargetOffset.setVec(0.f, 0.f, 0.10f);
  1421. part->mCameraOffset.setVec(-0.4f, 0.05f, 0.10f);
  1422. panel->addSubpart( "Style", SUBPART_HAIR_STYLE, part );
  1424. part = new LLSubpart();
  1425. part->mTargetJoint = "mHead";
  1426. part->mEditGroup = "hair_eyebrows";
  1427. part->mTargetOffset.setVec(0.f, 0.f, 0.05f);
  1428. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f);
  1429. panel->addSubpart( "Eyebrows", SUBPART_HAIR_EYEBROWS, part );
  1431. part = new LLSubpart();
  1432. part->mSex = SEX_MALE;
  1433. part->mTargetJoint = "mHead";
  1434. part->mEditGroup = "hair_facial";
  1435. part->mTargetOffset.setVec(0.f, 0.f, 0.05f);
  1436. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f);
  1437. panel->addSubpart( "Facial", SUBPART_HAIR_FACIAL, part );
  1439. panel->addTextureDropTarget(TEX_HAIR, "Texture",
  1440. LLUUID( gSavedSettings.getString( "UIImgDefaultHairUUID" ) ),
  1441. FALSE );
  1443. /////////////////////////////////////////
  1444. // Eyes
  1445. panel = mWearablePanelList[ WT_EYES ];
  1447. part = new LLSubpart();
  1448. part->mTargetJoint = "mHead";
  1449. part->mEditGroup = "eyes";
  1450. part->mTargetOffset.setVec(0.f, 0.f, 0.05f);
  1451. part->mCameraOffset.setVec(-0.5f, 0.05f, 0.07f);
  1452. panel->addSubpart( LLStringUtil::null, SUBPART_EYES, part );
  1454. panel->addTextureDropTarget(TEX_EYES_IRIS, "Iris",
  1455. LLUUID( gSavedSettings.getString( "UIImgDefaultEyesUUID" ) ),
  1456. FALSE );
  1458. /////////////////////////////////////////
  1459. // Shirt
  1460. panel = mWearablePanelList[ WT_SHIRT ];
  1462. part = new LLSubpart();
  1463. part->mTargetJoint = "mTorso";
  1464. part->mEditGroup = "shirt";
  1465. part->mTargetOffset.setVec(0.f, 0.f, 0.3f);
  1466. part->mCameraOffset.setVec(-1.f, 0.15f, 0.3f);
  1467. panel->addSubpart( LLStringUtil::null, SUBPART_SHIRT, part );
  1469. panel->addTextureDropTarget( TEX_UPPER_SHIRT, "Fabric",
  1470.  LLUUID( gSavedSettings.getString( "UIImgDefaultShirtUUID" ) ),
  1471.  FALSE );
  1473. panel->addColorSwatch( TEX_UPPER_SHIRT, "Color/Tint" );
  1476. /////////////////////////////////////////
  1477. // Pants
  1478. panel = mWearablePanelList[ WT_PANTS ];
  1480. part = new LLSubpart();
  1481. part->mTargetJoint = "mPelvis";
  1482. part->mEditGroup = "pants";
  1483. part->mTargetOffset.setVec(0.f, 0.f, -0.5f);
  1484. part->mCameraOffset.setVec(-1.6f, 0.15f, -0.5f);
  1485. panel->addSubpart( LLStringUtil::null, SUBPART_PANTS, part );
  1487. panel->addTextureDropTarget(TEX_LOWER_PANTS, "Fabric",
  1488. LLUUID( gSavedSettings.getString( "UIImgDefaultPantsUUID" ) ),
  1489. FALSE );
  1491. panel->addColorSwatch( TEX_LOWER_PANTS, "Color/Tint" );
  1494. /////////////////////////////////////////
  1495. // Shoes
  1496. panel = mWearablePanelList[ WT_SHOES ];
  1498. if (panel)
  1499. {
  1500. part = new LLSubpart();
  1501. part->mTargetJoint = "mPelvis";
  1502. part->mEditGroup = "shoes";
  1503. part->mTargetOffset.setVec(0.f, 0.f, -0.5f);
  1504. part->mCameraOffset.setVec(-1.6f, 0.15f, -0.5f);
  1505. panel->addSubpart( LLStringUtil::null, SUBPART_SHOES, part );
  1507. panel->addTextureDropTarget( TEX_LOWER_SHOES, "Fabric",
  1508.  LLUUID( gSavedSettings.getString( "UIImgDefaultShoesUUID" ) ),
  1509.  FALSE );
  1511. panel->addColorSwatch( TEX_LOWER_SHOES, "Color/Tint" );
  1512. }
  1515. /////////////////////////////////////////
  1516. // Socks
  1517. panel = mWearablePanelList[ WT_SOCKS ];
  1519. if (panel)
  1520. {
  1521. part = new LLSubpart();
  1522. part->mTargetJoint = "mPelvis";
  1523. part->mEditGroup = "socks";
  1524. part->mTargetOffset.setVec(0.f, 0.f, -0.5f);
  1525. part->mCameraOffset.setVec(-1.6f, 0.15f, -0.5f);
  1526. panel->addSubpart( LLStringUtil::null, SUBPART_SOCKS, part );
  1528. panel->addTextureDropTarget( TEX_LOWER_SOCKS, "Fabric",
  1529.  LLUUID( gSavedSettings.getString( "UIImgDefaultSocksUUID" ) ),
  1530.  FALSE );
  1532. panel->addColorSwatch( TEX_LOWER_SOCKS, "Color/Tint" );
  1533. }
  1535. /////////////////////////////////////////
  1536. // Jacket
  1537. panel = mWearablePanelList[ WT_JACKET ];
  1539. if (panel)
  1540. {
  1541. part = new LLSubpart();
  1542. part->mTargetJoint = "mTorso";
  1543. part->mEditGroup = "jacket";
  1544. part->mTargetOffset.setVec(0.f, 0.f, 0.f);
  1545. part->mCameraOffset.setVec(-2.f, 0.1f, 0.3f);
  1546. panel->addSubpart( LLStringUtil::null, SUBPART_JACKET, part );
  1548. panel->addTextureDropTarget( TEX_UPPER_JACKET, "Upper Fabric",
  1549.  LLUUID( gSavedSettings.getString( "UIImgDefaultJacketUUID" ) ),
  1550.  FALSE );
  1551. panel->addTextureDropTarget( TEX_LOWER_JACKET, "Lower Fabric",
  1552.  LLUUID( gSavedSettings.getString( "UIImgDefaultJacketUUID" ) ),
  1553.  FALSE );
  1555. panel->addColorSwatch( TEX_UPPER_JACKET, "Color/Tint" );
  1556. }
  1558. /////////////////////////////////////////
  1559. // Skirt
  1560. panel = mWearablePanelList[ WT_SKIRT ];
  1562. if (panel)
  1563. {
  1564. part = new LLSubpart();
  1565. part->mTargetJoint = "mPelvis";
  1566. part->mEditGroup = "skirt";
  1567. part->mTargetOffset.setVec(0.f, 0.f, -0.5f);
  1568. part->mCameraOffset.setVec(-1.6f, 0.15f, -0.5f);
  1569. panel->addSubpart( LLStringUtil::null, SUBPART_SKIRT, part );
  1571. panel->addTextureDropTarget( TEX_SKIRT,  "Fabric",
  1572.  LLUUID( gSavedSettings.getString( "UIImgDefaultSkirtUUID" ) ),
  1573.  FALSE );
  1575. panel->addColorSwatch( TEX_SKIRT, "Color/Tint" );
  1576. }
  1579. /////////////////////////////////////////
  1580. // Gloves
  1581. panel = mWearablePanelList[ WT_GLOVES ];
  1583. if (panel)
  1584. {
  1585. part = new LLSubpart();
  1586. part->mTargetJoint = "mTorso";
  1587. part->mEditGroup = "gloves";
  1588. part->mTargetOffset.setVec(0.f, 0.f, 0.f);
  1589. part->mCameraOffset.setVec(-1.f, 0.15f, 0.f);
  1590. panel->addSubpart( LLStringUtil::null, SUBPART_GLOVES, part );
  1592. panel->addTextureDropTarget( TEX_UPPER_GLOVES,  "Fabric",
  1593.  LLUUID( gSavedSettings.getString( "UIImgDefaultGlovesUUID" ) ),
  1594.  FALSE );
  1596. panel->addColorSwatch( TEX_UPPER_GLOVES, "Color/Tint" );
  1597. }
  1600. /////////////////////////////////////////
  1601. // Undershirt
  1602. panel = mWearablePanelList[ WT_UNDERSHIRT ];
  1604. if (panel)
  1605. {
  1606. part = new LLSubpart();
  1607. part->mTargetJoint = "mTorso";
  1608. part->mEditGroup = "undershirt";
  1609. part->mTargetOffset.setVec(0.f, 0.f, 0.3f);
  1610. part->mCameraOffset.setVec(-1.f, 0.15f, 0.3f);
  1611. panel->addSubpart( LLStringUtil::null, SUBPART_UNDERSHIRT, part );
  1613. panel->addTextureDropTarget( TEX_UPPER_UNDERSHIRT,  "Fabric",
  1614.  LLUUID( gSavedSettings.getString( "UIImgDefaultUnderwearUUID" ) ),
  1615.  FALSE );
  1617. panel->addColorSwatch( TEX_UPPER_UNDERSHIRT, "Color/Tint" );
  1618. }
  1620. /////////////////////////////////////////
  1621. // Underpants
  1622. panel = mWearablePanelList[ WT_UNDERPANTS ];
  1624. if (panel)
  1625. {
  1626. part = new LLSubpart();
  1627. part->mTargetJoint = "mPelvis";
  1628. part->mEditGroup = "underpants";
  1629. part->mTargetOffset.setVec(0.f, 0.f, -0.5f);
  1630. part->mCameraOffset.setVec(-1.6f, 0.15f, -0.5f);
  1631. panel->addSubpart( LLStringUtil::null, SUBPART_UNDERPANTS, part );
  1633. panel->addTextureDropTarget( TEX_LOWER_UNDERPANTS, "Fabric",
  1634.  LLUUID( gSavedSettings.getString( "UIImgDefaultUnderwearUUID" ) ),
  1635.  FALSE );
  1637. panel->addColorSwatch( TEX_LOWER_UNDERPANTS, "Color/Tint" );
  1638. }
  1640. /////////////////////////////////////////
  1641. // Alpha
  1642. panel = mWearablePanelList[ WT_ALPHA ];
  1644. if (panel)
  1645. {
  1646. part = new LLSubpart();
  1647. part->mTargetJoint = "mPelvis";
  1648. part->mEditGroup = "alpha";
  1649. part->mTargetOffset.setVec(0.f, 0.f, 0.1f);
  1650. part->mCameraOffset.setVec(-2.5f, 0.5f, 0.8f);
  1651. panel->addSubpart( LLStringUtil::null, SUBPART_ALPHA, part );
  1653. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_LOWER_ALPHA, "Lower Alpha",
  1654.  LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ),
  1655.  TRUE );
  1656. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_UPPER_ALPHA, "Upper Alpha",
  1657.  LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ),
  1658.  TRUE );
  1659. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_HEAD_ALPHA, "Head Alpha",
  1660.  LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ),
  1661.  TRUE );
  1662. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_EYES_ALPHA, "Eye Alpha",
  1663.  LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ),
  1664.  TRUE );
  1665. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_HAIR_ALPHA, "Hair Alpha",
  1666.  LLUUID( gSavedSettings.getString( "UIImgDefaultAlphaUUID" ) ),
  1667.  TRUE );
  1669. panel->addInvisibilityCheckbox( LLVOAvatarDefines::TEX_LOWER_ALPHA, "lower alpha texture invisible" );
  1670. panel->addInvisibilityCheckbox( LLVOAvatarDefines::TEX_UPPER_ALPHA, "upper alpha texture invisible" );
  1671. panel->addInvisibilityCheckbox( LLVOAvatarDefines::TEX_HEAD_ALPHA, "head alpha texture invisible" );
  1672. panel->addInvisibilityCheckbox( LLVOAvatarDefines::TEX_EYES_ALPHA, "eye alpha texture invisible" );
  1673. panel->addInvisibilityCheckbox( LLVOAvatarDefines::TEX_HAIR_ALPHA, "hair alpha texture invisible" );
  1674. }
  1676. /////////////////////////////////////////
  1677. // Tattoo
  1678. panel = mWearablePanelList[ WT_TATTOO ];
  1680. if (panel)
  1681. {
  1682. part = new LLSubpart();
  1683. part->mTargetJoint = "mPelvis";
  1684. part->mEditGroup = "tattoo";
  1685. part->mTargetOffset.setVec(0.f, 0.f, 0.1f);
  1686. part->mCameraOffset.setVec(-2.5f, 0.5f, 0.8f);
  1687. panel->addSubpart( LLStringUtil::null, SUBPART_TATTOO, part );
  1689. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_LOWER_TATTOO, "Lower Tattoo",
  1690.  LLUUID::null,
  1691.  TRUE );
  1692. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_UPPER_TATTOO, "Upper Tattoo",
  1693.  LLUUID::null,
  1694.  TRUE );
  1695. panel->addTextureDropTarget( LLVOAvatarDefines::TEX_HEAD_TATTOO, "Head Tattoo",
  1696.  LLUUID::null,
  1697.  TRUE );
  1698. }
  1699. }
  1701. ////////////////////////////////////////////////////////////////////////////
  1703. LLFloaterCustomize::~LLFloaterCustomize()
  1704. {
  1705. // Close these panels now, since they have elements that depend on parents,
  1706. // which would cause a crash under the normal order of deletion.
  1707. for (U8 i=0; i < WT_COUNT; i++)
  1708. {
  1709. LLPanelWearable* wearable_panel = mWearablePanelList[i];
  1710. if (wearable_panel)
  1711. {
  1712. wearable_panel->onParentFloaterClosed();
  1713. }
  1714. }
  1716. llinfos << "Destroying LLFloaterCustomize" << llendl;
  1717. gInventory.removeObserver(mInventoryObserver);
  1718. delete mInventoryObserver;
  1720. }
  1722. void LLFloaterCustomize::switchToDefaultSubpart()
  1723. {
  1724. getCurrentWearablePanel()->switchToDefaultSubpart();
  1725. }
  1727. void LLFloaterCustomize::draw()
  1728. {
  1729. if( isMinimized() )
  1730. {
  1731. LLFloater::draw();
  1732. return;
  1733. }
  1735. // only do this if we are in the customize avatar mode
  1736. // and not transitioning into or out of it
  1737. // *TODO: This is a sort of expensive call, which only needs
  1738. // to be called when the tabs change or an inventory item
  1739. // arrives. Figure out some way to avoid this if possible.
  1740. updateInventoryUI();
  1742. LLScrollingPanelParam::sUpdateDelayFrames = 0;
  1744. LLFloater::draw();
  1745. }
  1747. BOOL LLFloaterCustomize::isDirty() const
  1748. {
  1749. for(S32 i = 0; i < WT_COUNT; i++)
  1750. {
  1751. if( mWearablePanelList[i]
  1752. && mWearablePanelList[i]->isDirty() )
  1753. {
  1754. return TRUE;
  1755. }
  1756. }
  1757. return FALSE;
  1758. }
  1760. bool LLFloaterCustomize::onTabPrecommit(LLUICtrl* ctrl, const LLSD& data)
  1761. {
  1762. std::string panel_name = data.asString();
  1763. EWearableType type = get_wearable_type_from_panel_name(panel_name);
  1764. if (type != WT_INVALID && getCurrentWearableType() != type)
  1765. {
  1766. // Do a redundant isDirty() call to avoid infinite recursion
  1767. //  i.e. if not dirty, return true and do a normal commit
  1768. if( isDirty())
  1769. {
  1770. askToSaveIfDirty(boost::bind(&LLFloaterCustomize::onCommitChangeTab, this, _1, ctrl, panel_name));
  1771. return false;
  1772. }
  1773. else
  1774. {
  1775. return true;
  1776. }
  1777. }
  1778. else
  1779. {
  1780. return true;
  1781. }
  1782. }
  1785. void LLFloaterCustomize::onTabChanged( const LLSD& data )
  1786. {
  1787. std::string panel_name = data.asString();
  1788. EWearableType type = get_wearable_type_from_panel_name(panel_name);
  1789. if (type != WT_INVALID)
  1790. setCurrentWearableType( type );
  1791. }
  1793. //virtual
  1794. BOOL LLFloaterCustomize::canClose()
  1795. {
  1796. // *TODO: Hack! Fix this!
  1798. // since this window is potentially staying open, push to back to let next window take focus
  1799. gFloaterView->sendChildToBack(this);
  1800. handle_reset_view();  // Calls askToSaveIfDirty
  1801. return FALSE; // LLFloaterCustomize is never closed, just destroyed
  1802. }
  1804. void LLFloaterCustomize::onCommitChangeTab(BOOL proceed, LLUICtrl* ctrl, const std::string& selected_tab)
  1805. {
  1806. if (!proceed)
  1807. {
  1808. return;
  1809. }
  1811. LLTabContainer* tab_container = dynamic_cast<LLTabContainer*>(ctrl);
  1812. if (tab_container)
  1813. {
  1814. // Note: This will trigger the precommit / commit callbacks again,
  1815. //  make sure this will succeed (i.e. never produce an infinite loop)
  1816. tab_container->selectTabByName(selected_tab);
  1817. }
  1818. }
  1822. ////////////////////////////////////////////////////////////////////////////
  1824. void LLFloaterCustomize::clearScrollingPanelList()
  1825. {
  1826. if( mScrollingPanelList )
  1827. {
  1828. mScrollingPanelList->clearPanels();
  1829. }
  1830. }
  1832. void LLFloaterCustomize::generateVisualParamHints(LLViewerJointMesh* joint_mesh, LLFloaterCustomize::param_map& params, LLPanelWearable* panel)
  1833. {
  1834. // sorted_params is sorted according to magnitude of effect from
  1835. // least to greatest.  Adding to the front of the child list
  1836. // reverses that order.
  1837. if( mScrollingPanelList )
  1838. {
  1839. mScrollingPanelList->clearPanels();
  1840. param_map::iterator end = params.end();
  1841. for(param_map::iterator it = params.begin(); it != end; ++it)
  1842. {
  1843. LLPanel::Params p;
  1844. p.name("LLScrollingPanelParam");
  1845. p.rect(LLRect(0, LLScrollingPanelParam::PARAM_PANEL_HEIGHT, LLScrollingPanelParam::PARAM_PANEL_WIDTH, 0 ));
  1846. LLScrollingPanelParam* panel_param = new LLScrollingPanelParam( p, joint_mesh, (*it).second.second, (*it).second.first, panel->getWearable());
  1847. mScrollingPanelList->addPanel( panel_param );
  1848. }
  1849. }
  1850. }
  1852. LLPanelWearable* LLFloaterCustomize::getCurrentWearablePanel() 
  1853. { 
  1854. llassert(mCurrentWearableType >= 0 && mCurrentWearableType < WT_COUNT);
  1855. if (mCurrentWearableType < 0 || mCurrentWearableType >= WT_COUNT)
  1856. {
  1857. llwarns << "Invalid wearable type: " << mCurrentWearableType << llendl;
  1858. return NULL;
  1859. }
  1860. return mWearablePanelList[ mCurrentWearableType ]; 
  1861. }
  1864. void LLFloaterCustomize::setWearable(EWearableType type, LLWearable* wearable, U32 perm_mask, BOOL is_complete)
  1865. {
  1866. llassert( type < WT_COUNT );
  1867. gSavedSettings.setU32("AvatarSex", (gAgent.getAvatarObject()->getSex() == SEX_MALE) );
  1869. LLPanelWearable* panel = mWearablePanelList[ type ];
  1870. if( panel )
  1871. {
  1872. panel->setWearable(wearable, perm_mask, is_complete);
  1873. updateScrollingPanelList((perm_mask & PERM_MODIFY) ? is_complete : FALSE);
  1874. }
  1875. }
  1877. void LLFloaterCustomize::setWearable(EWearableType type, U32 index)
  1878. {
  1879. LLWearable *wearable = gAgentWearables.getWearable(type,index);
  1880. LLViewerInventoryItem* item;
  1881. // MULTI_WEARABLE:
  1882. item = (LLViewerInventoryItem*)gInventory.getItem(gAgentWearables.getWearableItemID(type,index));
  1883. U32 perm_mask = PERM_NONE;
  1884. BOOL is_complete = FALSE;
  1885. if(item)
  1886. {
  1887. perm_mask = item->getPermissions().getMaskOwner();
  1888. is_complete = item->isComplete();
  1889. if(!is_complete)
  1890. {
  1891. item->fetchFromServer();
  1892. }
  1893. }
  1894. setWearable(type,wearable,perm_mask,is_complete);
  1895. }
  1897. void LLFloaterCustomize::updateScrollingPanelList(BOOL allow_modify)
  1898. {
  1899. if( mScrollingPanelList )
  1900. {
  1901. LLScrollingPanelParam::sUpdateDelayFrames = 0;
  1902. mScrollingPanelList->updatePanels(allow_modify );
  1903. }
  1904. }
  1907. void LLFloaterCustomize::askToSaveIfDirty( next_step_callback_t next_step_callback )
  1908. {
  1909. if( isDirty())
  1910. {
  1911. // Ask if user wants to save, then continue to next step afterwards
  1912. mNextStepAfterSaveCallback = next_step_callback;
  1914. // Bring up view-modal dialog: Save changes? Yes, No, Cancel
  1915. LLNotificationsUtil::add("SaveClothingBodyChanges", LLSD(), LLSD(),
  1916. boost::bind(&LLFloaterCustomize::onSaveDialog, this, _1, _2));
  1917. }
  1918. else
  1919. {
  1920. next_step_callback( TRUE );
  1921. }
  1922. }
  1925. bool LLFloaterCustomize::onSaveDialog(const LLSD& notification, const LLSD& response )
  1926. {
  1927. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  1929. BOOL proceed = FALSE;
  1930. EWearableType cur = getCurrentWearableType();
  1932. switch( option )
  1933. {
  1934. case 0:  // "Save"
  1935. // MULTI_WEARABLE:
  1936. gAgentWearables.saveWearable( cur, 0 );
  1937. setWearable( cur, 0 );
  1938. getCurrentWearablePanel()->reset();
  1939. proceed = TRUE;
  1940. break;
  1942. case 1:  // "Don't Save"
  1943. {
  1944. // MULTI_WEARABLE:
  1945. gAgentWearables.revertWearable( cur, 0 );
  1946. proceed = TRUE;
  1947. }
  1948. break;
  1950. case 2: // "Cancel"
  1951. break;
  1953. default:
  1954. llassert(0);
  1955. break;
  1956. }
  1958. if( mNextStepAfterSaveCallback )
  1959. {
  1960. mNextStepAfterSaveCallback( proceed );
  1961. }
  1962. return false;
  1963. }
  1965. // fetch observer
  1966. class LLCurrentlyWorn : public LLInventoryFetchObserver
  1967. {
  1968. public:
  1969. LLCurrentlyWorn() {}
  1970. ~LLCurrentlyWorn() {}
  1971. virtual void done() { /* no operation necessary */}
  1972. };
  1974. void LLFloaterCustomize::fetchInventory()
  1975. {
  1976. // Fetch currently worn items
  1977. LLInventoryFetchObserver::item_ref_t ids;
  1978. LLUUID item_id;
  1979. for(S32 type = (S32)WT_SHAPE; type < (S32)WT_COUNT; ++type)
  1980. {
  1981. // MULTI_WEARABLE:
  1982. item_id = gAgentWearables.getWearableItemID((EWearableType)type,0);
  1983. if(item_id.notNull())
  1984. {
  1985. ids.push_back(item_id);
  1986. }
  1987. }
  1989. // Fire & forget. The mInventoryObserver will catch inventory
  1990. // updates and correct the UI as necessary.
  1991. LLCurrentlyWorn worn;
  1992. worn.fetchItems(ids);
  1993. }
  1995. void LLFloaterCustomize::updateInventoryUI()
  1996. {
  1997. BOOL all_complete = TRUE;
  1998. BOOL is_complete = FALSE;
  1999. U32 perm_mask = 0x0;
  2000. LLPanelWearable* panel = NULL;
  2001. LLViewerInventoryItem* item = NULL;
  2002. for(S32 i = 0; i < WT_COUNT; ++i)
  2003. {
  2004. item = NULL;
  2005. panel = mWearablePanelList[i];
  2006. if(panel)
  2007. {
  2008. // MULTI_WEARABLE:
  2009. item = (LLViewerInventoryItem*)gAgentWearables.getWearableInventoryItem(panel->getType(),0);
  2010. }
  2011. if(item)
  2012. {
  2013. is_complete = item->isComplete();
  2014. if(!is_complete)
  2015. {
  2016. all_complete = FALSE;
  2017. }
  2018. perm_mask = item->getPermissions().getMaskOwner();
  2019. }
  2020. else
  2021. {
  2022. is_complete = false;
  2023. perm_mask = 0x0;
  2024. }
  2025. if(i == mCurrentWearableType)
  2026. {
  2027. if(panel)
  2028. {
  2029.      panel->setUIPermissions(perm_mask, is_complete);
  2030. }
  2031. BOOL is_vis = panel && item && is_complete && (perm_mask & PERM_MODIFY);
  2032. childSetVisible("panel_container", is_vis);
  2033. }
  2034. }
  2035. childSetEnabled("Make Outfit", all_complete);
  2036. }
  2038. void LLFloaterCustomize::updateScrollingPanelUI()
  2039. {
  2040. LLPanelWearable* panel = mWearablePanelList[mCurrentWearableType];
  2041. if(panel && (panel->getWearable() != NULL) && (panel->getWearable()->getItemID().notNull()))
  2042. {
  2043. LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(panel->getWearable()->getItemID());
  2044. if(item)
  2045. {
  2046. U32 perm_mask = item->getPermissions().getMaskOwner();
  2047. BOOL is_complete = item->isComplete();
  2048. updateScrollingPanelList((perm_mask & PERM_MODIFY) ? is_complete : FALSE);
  2049. }
  2050. }
  2051. }