EXT-7305 : FIXED : Changed LLWearableDictionary to LLWearableType

Refactored LLWearableDictionary to look more like LLAssetType/LLFolderType/etc. in terms of code design.  This required a lot of superficial changes across many files.  Overall functionality has not changed.

34 files changed, 422 insertions, 422 deletions

diff --git a/indra/llinventory/llinventorydefines.h b/indra/llinventory/llinventorydefines.h
index ccf1a356de..67e629c546 100644
--- a/indra/llinventory/llinventorydefines.h
+++ b/indra/llinventory/llinventorydefines.h
@@ -89,7 +89,7 @@ public:
 
 		II_FLAGS_WEARABLES_MASK = 0xff,
 			// Wearables use the low order byte of flags to store the
-			// EWearableType enumeration found in newview/llwearable.h
+			// LLWearableType::EType enumeration found in newview/llwearable.h
 
 		II_FLAGS_PERM_OVERWRITE_MASK = 				(II_FLAGS_OBJECT_SLAM_PERM |
 													 II_FLAGS_OBJECT_SLAM_SALE |
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 88ba5dce11..7d6fd68af7 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -3558,7 +3558,7 @@ void LLAgent::sendAgentSetAppearance()
 		const ETextureIndex texture_index = LLVOAvatarDictionary::bakedToLocalTextureIndex((EBakedTextureIndex)baked_index);
 
 		// if we're not wearing a skirt, we don't need the texture to be baked
-		if (texture_index == TEX_SKIRT_BAKED && !gAgentAvatarp->isWearingWearableType(WT_SKIRT))
+		if (texture_index == TEX_SKIRT_BAKED && !gAgentAvatarp->isWearingWearableType(LLWearableType::WT_SKIRT))
 		{
 			continue;
 		}
@@ -3581,8 +3581,8 @@ void LLAgent::sendAgentSetAppearance()
 			LLUUID hash;
 			for (U8 i=0; i < baked_dict->mWearables.size(); i++)
 			{
-				// EWearableType wearable_type = gBakedWearableMap[baked_index][wearable_num];
-				const EWearableType wearable_type = baked_dict->mWearables[i];
+				// LLWearableType::EType wearable_type = gBakedWearableMap[baked_index][wearable_num];
+				const LLWearableType::EType wearable_type = baked_dict->mWearables[i];
 				// MULTI-WEARABLE: fixed to 0th - extend to everything once messaging works.
 				const LLWearable* wearable = gAgentWearables.getWearable(wearable_type,0);
 				if (wearable)
diff --git a/indra/newview/llagentwearables.cpp b/indra/newview/llagentwearables.cpp
index 47735e7179..3e73bbef15 100644
--- a/indra/newview/llagentwearables.cpp
+++ b/indra/newview/llagentwearables.cpp
@@ -100,13 +100,13 @@ void checkWearableAgainstInventory(LLWearable *wearable)
 void LLAgentWearables::dump()
 {
 	llinfos << "LLAgentWearablesDump" << llendl;
-	for (S32 i = 0; i < WT_COUNT; i++)
+	for (S32 i = 0; i < LLWearableType::WT_COUNT; i++)
 	{
-		U32 count = getWearableCount((EWearableType)i);
+		U32 count = getWearableCount((LLWearableType::EType)i);
 		llinfos << "Type: " << i << " count " << count << llendl;
 		for (U32 j=0; j<count; j++)
 		{
-			LLWearable* wearable = getWearable((EWearableType)i,j);
+			LLWearable* wearable = getWearable((LLWearableType::EType)i,j);
 			if (wearable == NULL)
 			{
 				llinfos << "    " << j << " NULL wearable" << llendl;
@@ -250,7 +250,7 @@ void LLAgentWearables::addWearabletoAgentInventoryDone(const S32 type,
 	if (item_id.isNull())
 		return;
 
-	LLUUID old_item_id = getWearableItemID((EWearableType)type,index);
+	LLUUID old_item_id = getWearableItemID((LLWearableType::EType)type,index);
 
 	if (wearable)
 	{
@@ -259,11 +259,11 @@ void LLAgentWearables::addWearabletoAgentInventoryDone(const S32 type,
 		if (old_item_id.notNull())
 		{	
 			gInventory.addChangedMask(LLInventoryObserver::LABEL, old_item_id);
-			setWearable((EWearableType)type,index,wearable);
+			setWearable((LLWearableType::EType)type,index,wearable);
 		}
 		else
 		{
-			pushWearable((EWearableType)type,wearable);
+			pushWearable((LLWearableType::EType)type,wearable);
 		}
 	}
 
@@ -287,11 +287,11 @@ void LLAgentWearables::sendAgentWearablesUpdate()
 {
 	// MULTI-WEARABLE: call i "type" or something.
 	// First make sure that we have inventory items for each wearable
-	for (S32 type=0; type < WT_COUNT; ++type)
+	for (S32 type=0; type < LLWearableType::WT_COUNT; ++type)
 	{
-		for (U32 j=0; j < getWearableCount((EWearableType)type); ++j)
+		for (U32 j=0; j < getWearableCount((LLWearableType::EType)type); ++j)
 		{
-			LLWearable* wearable = getWearable((EWearableType)type,j);
+			LLWearable* wearable = getWearable((LLWearableType::EType)type,j);
 			if (wearable)
 			{
 				if (wearable->getItemID().isNull())
@@ -326,7 +326,7 @@ void LLAgentWearables::sendAgentWearablesUpdate()
 
 	lldebugs << "sendAgentWearablesUpdate()" << llendl;
 	// MULTI-WEARABLE: update for multi-wearables after server-side support is in.
-	for (S32 type=0; type < WT_COUNT; ++type)
+	for (S32 type=0; type < LLWearableType::WT_COUNT; ++type)
 	{
 		gMessageSystem->nextBlockFast(_PREHASH_WearableData);
 
@@ -334,7 +334,7 @@ void LLAgentWearables::sendAgentWearablesUpdate()
 		gMessageSystem->addU8Fast(_PREHASH_WearableType, type_u8);
 
 		// MULTI-WEARABLE: TODO: hacked index to 0, needs to loop over all once messages support this.
-		LLWearable* wearable = getWearable((EWearableType)type, 0);
+		LLWearable* wearable = getWearable((LLWearableType::EType)type, 0);
 		if (wearable)
 		{
 			//llinfos << "Sending wearable " << wearable->getName() << llendl;
@@ -350,16 +350,16 @@ void LLAgentWearables::sendAgentWearablesUpdate()
 		}
 		else
 		{
-			//llinfos << "Not wearing wearable type " << LLWearableDictionary::getInstance()->getWearable((EWearableType)i) << llendl;
+			//llinfos << "Not wearing wearable type " << LLWearableType::getTypeName((LLWearableType::EType)i) << llendl;
 			gMessageSystem->addUUIDFast(_PREHASH_ItemID, LLUUID::null);
 		}
 
-		lldebugs << "       " << LLWearableDictionary::getTypeLabel((EWearableType)type) << ": " << (wearable ? wearable->getAssetID() : LLUUID::null) << llendl;
+		lldebugs << "       " << LLWearableType::getTypeLabel((LLWearableType::EType)type) << ": " << (wearable ? wearable->getAssetID() : LLUUID::null) << llendl;
 	}
 	gAgent.sendReliableMessage();
 }
 
-void LLAgentWearables::saveWearable(const EWearableType type, const U32 index, BOOL send_update)
+void LLAgentWearables::saveWearable(const LLWearableType::EType type, const U32 index, BOOL send_update)
 {
 	LLWearable* old_wearable = getWearable(type, index);
 	if (old_wearable && (old_wearable->isDirty() || old_wearable->isOldVersion()))
@@ -422,7 +422,7 @@ void LLAgentWearables::saveWearable(const EWearableType type, const U32 index, B
 	}
 }
 
-void LLAgentWearables::saveWearableAs(const EWearableType type,
+void LLAgentWearables::saveWearableAs(const LLWearableType::EType type,
 									  const U32 index,
 									  const std::string& new_name,
 									  BOOL save_in_lost_and_found)
@@ -483,7 +483,7 @@ void LLAgentWearables::saveWearableAs(const EWearableType type,
 	old_wearable->revertValues();
 }
 
-void LLAgentWearables::revertWearable(const EWearableType type, const U32 index)
+void LLAgentWearables::revertWearable(const LLWearableType::EType type, const U32 index)
 {
 	LLWearable* wearable = getWearable(type, index);
 	wearable->revertValues();
@@ -498,10 +498,10 @@ void LLAgentWearables::saveAllWearables()
 	//	return;
 	//}
 
-	for (S32 i=0; i < WT_COUNT; i++)
+	for (S32 i=0; i < LLWearableType::WT_COUNT; i++)
 	{
-		for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
-			saveWearable((EWearableType)i, j, FALSE);
+		for (U32 j=0; j < getWearableCount((LLWearableType::EType)i); j++)
+			saveWearable((LLWearableType::EType)i, j, FALSE);
 	}
 	sendAgentWearablesUpdate();
 }
@@ -509,14 +509,14 @@ void LLAgentWearables::saveAllWearables()
 // Called when the user changes the name of a wearable inventory item that is currently being worn.
 void LLAgentWearables::setWearableName(const LLUUID& item_id, const std::string& new_name)
 {
-	for (S32 i=0; i < WT_COUNT; i++)
+	for (S32 i=0; i < LLWearableType::WT_COUNT; i++)
 	{
-		for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
+		for (U32 j=0; j < getWearableCount((LLWearableType::EType)i); j++)
 		{
-			LLUUID curr_item_id = getWearableItemID((EWearableType)i,j);
+			LLUUID curr_item_id = getWearableItemID((LLWearableType::EType)i,j);
 			if (curr_item_id == item_id)
 			{
-				LLWearable* old_wearable = getWearable((EWearableType)i,j);
+				LLWearable* old_wearable = getWearable((LLWearableType::EType)i,j);
 				llassert(old_wearable);
 
 				std::string old_name = old_wearable->getName();
@@ -530,7 +530,7 @@ void LLAgentWearables::setWearableName(const LLUUID& item_id, const std::string&
 				}
 				old_wearable->setName(old_name);
 
-				setWearable((EWearableType)i,j,new_wearable);
+				setWearable((LLWearableType::EType)i,j,new_wearable);
 				sendAgentWearablesUpdate();
 				break;
 			}
@@ -539,7 +539,7 @@ void LLAgentWearables::setWearableName(const LLUUID& item_id, const std::string&
 }
 
 
-BOOL LLAgentWearables::isWearableModifiable(EWearableType type, U32 index) const
+BOOL LLAgentWearables::isWearableModifiable(LLWearableType::EType type, U32 index) const
 {
 	LLUUID item_id = getWearableItemID(type, index);
 	if (!item_id.isNull())
@@ -554,7 +554,7 @@ BOOL LLAgentWearables::isWearableModifiable(EWearableType type, U32 index) const
 	return FALSE;
 }
 
-BOOL LLAgentWearables::isWearableCopyable(EWearableType type, U32 index) const
+BOOL LLAgentWearables::isWearableCopyable(LLWearableType::EType type, U32 index) const
 {
 	LLUUID item_id = getWearableItemID(type, index);
 	if (!item_id.isNull())
@@ -570,7 +570,7 @@ BOOL LLAgentWearables::isWearableCopyable(EWearableType type, U32 index) const
 }
 
 /*
-  U32 LLAgentWearables::getWearablePermMask(EWearableType type)
+  U32 LLAgentWearables::getWearablePermMask(LLWearableType::EType type)
   {
   LLUUID item_id = getWearableItemID(type);
   if (!item_id.isNull())
@@ -585,7 +585,7 @@ BOOL LLAgentWearables::isWearableCopyable(EWearableType type, U32 index) const
   }
 */
 
-LLInventoryItem* LLAgentWearables::getWearableInventoryItem(EWearableType type, U32 index)
+LLInventoryItem* LLAgentWearables::getWearableInventoryItem(LLWearableType::EType type, U32 index)
 {
 	LLUUID item_id = getWearableItemID(type,index);
 	LLInventoryItem* item = NULL;
@@ -598,11 +598,11 @@ LLInventoryItem* LLAgentWearables::getWearableInventoryItem(EWearableType type,
 
 const LLWearable* LLAgentWearables::getWearableFromItemID(const LLUUID& item_id) const
 {
-	for (S32 i=0; i < WT_COUNT; i++)
+	for (S32 i=0; i < LLWearableType::WT_COUNT; i++)
 	{
-		for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
+		for (U32 j=0; j < getWearableCount((LLWearableType::EType)i); j++)
 		{
-			const LLWearable * curr_wearable = getWearable((EWearableType)i, j);
+			const LLWearable * curr_wearable = getWearable((LLWearableType::EType)i, j);
 			if (curr_wearable && (curr_wearable->getItemID() == item_id))
 			{
 				return curr_wearable;
@@ -614,11 +614,11 @@ const LLWearable* LLAgentWearables::getWearableFromItemID(const LLUUID& item_id)
 
 LLWearable*	LLAgentWearables::getWearableFromAssetID(const LLUUID& asset_id) 
 {
-	for (S32 i=0; i < WT_COUNT; i++)
+	for (S32 i=0; i < LLWearableType::WT_COUNT; i++)
 	{
-		for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
+		for (U32 j=0; j < getWearableCount((LLWearableType::EType)i); j++)
 		{
-			LLWearable * curr_wearable = getWearable((EWearableType)i, j);
+			LLWearable * curr_wearable = getWearable((LLWearableType::EType)i, j);
 			if (curr_wearable && (curr_wearable->getAssetID() == asset_id))
 			{
 				return curr_wearable;
@@ -638,12 +638,12 @@ void LLAgentWearables::sendAgentWearablesRequest()
 }
 
 // static
-BOOL LLAgentWearables::selfHasWearable(EWearableType type)
+BOOL LLAgentWearables::selfHasWearable(LLWearableType::EType type)
 {
 	return (gAgentWearables.getWearableCount(type) > 0);
 }
 
-LLWearable* LLAgentWearables::getWearable(const EWearableType type, U32 index)
+LLWearable* LLAgentWearables::getWearable(const LLWearableType::EType type, U32 index)
 {
 	wearableentry_map_t::iterator wearable_iter = mWearableDatas.find(type);
 	if (wearable_iter == mWearableDatas.end())
@@ -661,7 +661,7 @@ LLWearable* LLAgentWearables::getWearable(const EWearableType type, U32 index)
 	}
 }
 
-void LLAgentWearables::setWearable(const EWearableType type, U32 index, LLWearable *wearable)
+void LLAgentWearables::setWearable(const LLWearableType::EType type, U32 index, LLWearable *wearable)
 {
 
 	LLWearable *old_wearable = getWearable(type,index);
@@ -691,7 +691,7 @@ void LLAgentWearables::setWearable(const EWearableType type, U32 index, LLWearab
 	}
 }
 
-U32 LLAgentWearables::pushWearable(const EWearableType type, LLWearable *wearable)
+U32 LLAgentWearables::pushWearable(const LLWearableType::EType type, LLWearable *wearable)
 {
 	if (wearable == NULL)
 	{
@@ -699,7 +699,7 @@ U32 LLAgentWearables::pushWearable(const EWearableType type, LLWearable *wearabl
 		llwarns << "Null wearable sent for type " << type << llendl;
 		return MAX_WEARABLES_PER_TYPE;
 	}
-	if (type < WT_COUNT || mWearableDatas[type].size() < MAX_WEARABLES_PER_TYPE)
+	if (type < LLWearableType::WT_COUNT || mWearableDatas[type].size() < MAX_WEARABLES_PER_TYPE)
 	{
 		mWearableDatas[type].push_back(wearable);
 		wearableUpdated(wearable);
@@ -741,7 +741,7 @@ void LLAgentWearables::popWearable(LLWearable *wearable)
 	}
 
 	U32 index = getWearableIndex(wearable);
-	EWearableType type = wearable->getType();
+	LLWearableType::EType type = wearable->getType();
 
 	if (index < MAX_WEARABLES_PER_TYPE && index < getWearableCount(type))
 	{
@@ -749,7 +749,7 @@ void LLAgentWearables::popWearable(LLWearable *wearable)
 	}
 }
 
-void LLAgentWearables::popWearable(const EWearableType type, U32 index)
+void LLAgentWearables::popWearable(const LLWearableType::EType type, U32 index)
 {
 	LLWearable *wearable = getWearable(type, index);
 	if (wearable)
@@ -767,7 +767,7 @@ U32	LLAgentWearables::getWearableIndex(LLWearable *wearable)
 		return MAX_WEARABLES_PER_TYPE;
 	}
 
-	const EWearableType type = wearable->getType();
+	const LLWearableType::EType type = wearable->getType();
 	wearableentry_map_t::const_iterator wearable_iter = mWearableDatas.find(type);
 	if (wearable_iter == mWearableDatas.end())
 	{
@@ -786,7 +786,7 @@ U32	LLAgentWearables::getWearableIndex(LLWearable *wearable)
 	return MAX_WEARABLES_PER_TYPE;
 }
 
-const LLWearable* LLAgentWearables::getWearable(const EWearableType type, U32 index) const
+const LLWearable* LLAgentWearables::getWearable(const LLWearableType::EType type, U32 index) const
 {
 	wearableentry_map_t::const_iterator wearable_iter = mWearableDatas.find(type);
 	if (wearable_iter == mWearableDatas.end())
@@ -804,7 +804,7 @@ const LLWearable* LLAgentWearables::getWearable(const EWearableType type, U32 in
 	}
 }
 
-LLWearable* LLAgentWearables::getTopWearable(const EWearableType type)
+LLWearable* LLAgentWearables::getTopWearable(const LLWearableType::EType type)
 {
 	U32 count = getWearableCount(type);
 	if ( count == 0)
@@ -815,7 +815,7 @@ LLWearable* LLAgentWearables::getTopWearable(const EWearableType type)
 	return getWearable(type, count-1);
 }
 
-U32 LLAgentWearables::getWearableCount(const EWearableType type) const
+U32 LLAgentWearables::getWearableCount(const LLWearableType::EType type) const
 {
 	wearableentry_map_t::const_iterator wearable_iter = mWearableDatas.find(type);
 	if (wearable_iter == mWearableDatas.end())
@@ -828,7 +828,7 @@ U32 LLAgentWearables::getWearableCount(const EWearableType type) const
 
 U32 LLAgentWearables::getWearableCount(const U32 tex_index) const
 {
-	const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType((LLVOAvatarDefines::ETextureIndex)tex_index);
+	const LLWearableType::EType wearable_type = LLVOAvatarDictionary::getTEWearableType((LLVOAvatarDefines::ETextureIndex)tex_index);
 	return getWearableCount(wearable_type);
 }
 
@@ -843,7 +843,7 @@ U32 LLAgentWearables::itemUpdatePendingCount() const
 	return mItemsAwaitingWearableUpdate.size();
 }
 
-const LLUUID LLAgentWearables::getWearableItemID(EWearableType type, U32 index) const
+const LLUUID LLAgentWearables::getWearableItemID(LLWearableType::EType type, U32 index) const
 {
 	const LLWearable *wearable = getWearable(type,index);
 	if (wearable)
@@ -852,7 +852,7 @@ const LLUUID LLAgentWearables::getWearableItemID(EWearableType type, U32 index)
 		return LLUUID();
 }
 
-const LLUUID LLAgentWearables::getWearableAssetID(EWearableType type, U32 index) const
+const LLUUID LLAgentWearables::getWearableAssetID(LLWearableType::EType type, U32 index) const
 {
 	const LLWearable *wearable = getWearable(type,index);
 	if (wearable)
@@ -916,11 +916,11 @@ void LLAgentWearables::processAgentInitialWearablesUpdate(LLMessageSystem* mesgs
 			// Parse initial wearables data from message system
 			U8 type_u8 = 0;
 			gMessageSystem->getU8Fast(_PREHASH_WearableData, _PREHASH_WearableType, type_u8, i);
-			if (type_u8 >= WT_COUNT)
+			if (type_u8 >= LLWearableType::WT_COUNT)
 			{
 				continue;
 			}
-			const EWearableType type = (EWearableType) type_u8;
+			const LLWearableType::EType type = (LLWearableType::EType) type_u8;
 			
 			LLUUID item_id;
 			gMessageSystem->getUUIDFast(_PREHASH_WearableData, _PREHASH_ItemID, item_id, i);
@@ -933,7 +933,7 @@ void LLAgentWearables::processAgentInitialWearablesUpdate(LLMessageSystem* mesgs
 			}
 			else
 			{
-				LLAssetType::EType asset_type = LLWearableDictionary::getAssetType(type);
+				LLAssetType::EType asset_type = LLWearableType::getAssetType(type);
 				if (asset_type == LLAssetType::AT_NONE)
 				{
 					continue;
@@ -946,7 +946,7 @@ void LLAgentWearables::processAgentInitialWearablesUpdate(LLMessageSystem* mesgs
 				outfit->add(wearable_data);
 			}
 			
-			lldebugs << "       " << LLWearableDictionary::getTypeLabel(type) << llendl;
+			lldebugs << "       " << LLWearableType::getTypeLabel(type) << llendl;
 		}
 		
 		// Get the complete information on the items in the inventory and set up an observer
@@ -970,11 +970,11 @@ void LLAgentWearables::processAgentInitialWearablesUpdate(LLMessageSystem* mesgs
 // Normally, all wearables referred to "AgentWearablesUpdate" will correspond to actual assets in the
 // database.  If for some reason, we can't load one of those assets, we can try to reconstruct it so that
 // the user isn't left without a shape, for example.  (We can do that only after the inventory has loaded.)
-void LLAgentWearables::recoverMissingWearable(const EWearableType type, U32 index)
+void LLAgentWearables::recoverMissingWearable(const LLWearableType::EType type, U32 index)
 {
 	// Try to recover by replacing missing wearable with a new one.
 	LLNotificationsUtil::add("ReplacedMissingWearable");
-	lldebugs << "Wearable " << LLWearableDictionary::getTypeLabel(type) << " could not be downloaded.  Replaced inventory item with default wearable." << llendl;
+	lldebugs << "Wearable " << LLWearableType::getTypeLabel(type) << " could not be downloaded.  Replaced inventory item with default wearable." << llendl;
 	LLWearable* new_wearable = LLWearableList::instance().createNewWearable(type);
 
 	S32 type_s32 = (S32) type;
@@ -1011,9 +1011,9 @@ void LLAgentWearables::recoverMissingWearableDone()
 	}
 }
 
-void LLAgentWearables::addLocalTextureObject(const EWearableType wearable_type, const LLVOAvatarDefines::ETextureIndex texture_type, U32 wearable_index)
+void LLAgentWearables::addLocalTextureObject(const LLWearableType::EType wearable_type, const LLVOAvatarDefines::ETextureIndex texture_type, U32 wearable_index)
 {
-	LLWearable* wearable = getWearable((EWearableType)wearable_type, wearable_index);
+	LLWearable* wearable = getWearable((LLWearableType::EType)wearable_type, wearable_index);
 	if (!wearable)
 	{
 		llerrs << "Tried to add local texture object to invalid wearable with type " << wearable_type << " and index " << wearable_index << llendl;
@@ -1027,7 +1027,7 @@ class OnWearableItemCreatedCB: public LLInventoryCallback
 {
 public:
 	OnWearableItemCreatedCB():
-		mWearablesAwaitingItems(WT_COUNT,NULL)
+		mWearablesAwaitingItems(LLWearableType::WT_COUNT,NULL)
 	{
 		llinfos << "created callback" << llendl;
 	}
@@ -1053,8 +1053,8 @@ public:
 			llwarns << "no wearable" << llendl;
 			return;
 		}
-		EWearableType type = wearable->getType();
-		if (type<WT_COUNT)
+		LLWearableType::EType type = wearable->getType();
+		if (type<LLWearableType::WT_COUNT)
 		{
 			mWearablesAwaitingItems[type] = wearable;
 		}
@@ -1078,8 +1078,8 @@ public:
 		}
 		if (item && item->isWearableType())
 		{
-			EWearableType type = item->getWearableType();
-			if (type < WT_COUNT)
+			LLWearableType::EType type = item->getWearableType();
+			if (type < LLWearableType::WT_COUNT)
 			{
 				LLWearable *wearable = mWearablesAwaitingItems[type];
 				if (wearable)
@@ -1106,30 +1106,30 @@ void LLAgentWearables::createStandardWearables(BOOL female)
 
 	gAgentAvatarp->setSex(female ? SEX_FEMALE : SEX_MALE);
 
-	const BOOL create[WT_COUNT] = 
+	const BOOL create[LLWearableType::WT_COUNT] = 
 		{
-			TRUE,  //WT_SHAPE
-			TRUE,  //WT_SKIN
-			TRUE,  //WT_HAIR
-			TRUE,  //WT_EYES
-			TRUE,  //WT_SHIRT
-			TRUE,  //WT_PANTS
-			TRUE,  //WT_SHOES
-			TRUE,  //WT_SOCKS
-			FALSE, //WT_JACKET
-			FALSE, //WT_GLOVES
-			TRUE,  //WT_UNDERSHIRT
-			TRUE,  //WT_UNDERPANTS
-			FALSE  //WT_SKIRT
+			TRUE,  //LLWearableType::WT_SHAPE
+			TRUE,  //LLWearableType::WT_SKIN
+			TRUE,  //LLWearableType::WT_HAIR
+			TRUE,  //LLWearableType::WT_EYES
+			TRUE,  //LLWearableType::WT_SHIRT
+			TRUE,  //LLWearableType::WT_PANTS
+			TRUE,  //LLWearableType::WT_SHOES
+			TRUE,  //LLWearableType::WT_SOCKS
+			FALSE, //LLWearableType::WT_JACKET
+			FALSE, //LLWearableType::WT_GLOVES
+			TRUE,  //LLWearableType::WT_UNDERSHIRT
+			TRUE,  //LLWearableType::WT_UNDERPANTS
+			FALSE  //LLWearableType::WT_SKIRT
 		};
 
 	LLPointer<LLInventoryCallback> cb = new OnWearableItemCreatedCB;
-	for (S32 i=0; i < WT_COUNT; i++)
+	for (S32 i=0; i < LLWearableType::WT_COUNT; i++)
 	{
 		if (create[i])
 		{
-			llassert(getWearableCount((EWearableType)i) == 0);
-			LLWearable* wearable = LLWearableList::instance().createNewWearable((EWearableType)i);
+			llassert(getWearableCount((LLWearableType::EType)i) == 0);
+			LLWearable* wearable = LLWearableList::instance().createNewWearable((LLWearableType::EType)i);
 			((OnWearableItemCreatedCB*)(&(*cb)))->addPendingWearable(wearable);
 			// no need to update here...
 			LLUUID category_id = LLUUID::null;
@@ -1175,16 +1175,16 @@ void LLAgentWearables::createStandardWearablesAllDone()
 // MULTI-WEARABLE: Properly handle multiwearables later.
 void LLAgentWearables::getAllWearablesArray(LLDynamicArray<S32>& wearables)
 {
-	for( S32 i = 0; i < WT_COUNT; ++i )
+	for( S32 i = 0; i < LLWearableType::WT_COUNT; ++i )
 	{
-		if (getWearableCount((EWearableType) i) !=  0)
+		if (getWearableCount((LLWearableType::EType) i) !=  0)
 		{
 			wearables.push_back(i);
 		}
 	}
 }
 
-// Note:	wearables_to_include should be a list of EWearableType types
+// Note:	wearables_to_include should be a list of LLWearableType::EType types
 //			attachments_to_include should be a list of attachment points
 void LLAgentWearables::makeNewOutfit(const std::string& new_folder_name,
 									 const LLDynamicArray<S32>& wearables_to_include,
@@ -1214,9 +1214,9 @@ void LLAgentWearables::makeNewOutfit(const std::string& new_folder_name,
 		for (i = 0; i < count; ++i)
 		{
 			const S32 type = wearables_to_include[i];
-			for (U32 j=0; j<getWearableCount((EWearableType)i); j++)
+			for (U32 j=0; j<getWearableCount((LLWearableType::EType)i); j++)
 			{
-				LLWearable* old_wearable = getWearable((EWearableType)type, j);
+				LLWearable* old_wearable = getWearable((LLWearableType::EType)type, j);
 				if (old_wearable)
 				{
 					std::string new_name;
@@ -1231,7 +1231,7 @@ void LLAgentWearables::makeNewOutfit(const std::string& new_folder_name,
 						new_wearable->setName(new_name);
 					}
 
-					LLViewerInventoryItem* item = gInventory.getItem(getWearableItemID((EWearableType)type,j));
+					LLViewerInventoryItem* item = gInventory.getItem(getWearableItemID((LLWearableType::EType)type,j));
 					S32 todo = addWearableToAgentInventoryCallback::CALL_NONE;
 					if (!found_first_item)
 					{
@@ -1251,7 +1251,7 @@ void LLAgentWearables::makeNewOutfit(const std::string& new_folder_name,
 					llassert(item);
 					if (item)
 					{
-						if (isWearableCopyable((EWearableType)type, j))
+						if (isWearableCopyable((LLWearableType::EType)type, j))
 						{
 							copy_inventory_item(
 									    gAgent.getID(),
@@ -1365,7 +1365,7 @@ private:
 
 void LLAgentWearables::makeNewOutfitDone(S32 type, U32 index)
 {
-	LLUUID first_item_id = getWearableItemID((EWearableType)type, index);
+	LLUUID first_item_id = getWearableItemID((LLWearableType::EType)type, index);
 	// Open the inventory and select the first item we added.
 	if (first_item_id.notNull())
 	{
@@ -1396,10 +1396,10 @@ void LLAgentWearables::addWearableToAgentInventory(LLPointer<LLInventoryCallback
 						  cb);
 }
 
-void LLAgentWearables::removeWearable(const EWearableType type, bool do_remove_all, U32 index)
+void LLAgentWearables::removeWearable(const LLWearableType::EType type, bool do_remove_all, U32 index)
 {
 	if (gAgent.isTeen() &&
-		(type == WT_UNDERSHIRT || type == WT_UNDERPANTS))
+		(type == LLWearableType::WT_UNDERSHIRT || type == LLWearableType::WT_UNDERPANTS))
 	{
 		// Can't take off underclothing in simple UI mode or on PG accounts
 		// TODO: enable the removing of a single undershirt/underpants if multiple are worn. - Nyx
@@ -1443,7 +1443,7 @@ void LLAgentWearables::removeWearable(const EWearableType type, bool do_remove_a
 bool LLAgentWearables::onRemoveWearableDialog(const LLSD& notification, const LLSD& response)
 {
 	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-	EWearableType type = (EWearableType)notification["payload"]["wearable_type"].asInteger();
+	LLWearableType::EType type = (LLWearableType::EType)notification["payload"]["wearable_type"].asInteger();
 	S32 index = (S32)notification["payload"]["wearable_index"].asInteger();
 	switch(option)
 	{
@@ -1467,7 +1467,7 @@ bool LLAgentWearables::onRemoveWearableDialog(const LLSD& notification, const LL
 }
 
 // Called by removeWearable() and onRemoveWearableDialog() to actually do the removal.
-void LLAgentWearables::removeWearableFinal(const EWearableType type, bool do_remove_all, U32 index)
+void LLAgentWearables::removeWearableFinal(const LLWearableType::EType type, bool do_remove_all, U32 index)
 {
 	//LLAgentDumper dumper("removeWearable");
 	if (do_remove_all)
@@ -1516,11 +1516,11 @@ void LLAgentWearables::setWearableOutfit(const LLInventoryItem::item_array_t& it
 	{
 		// note: shirt is the first non-body part wearable item. Update if wearable order changes.
 		// This loop should remove all clothing, but not any body parts
-		for (S32 type = 0; type < (S32)WT_COUNT; type++)
+		for (S32 type = 0; type < (S32)LLWearableType::WT_COUNT; type++)
 		{
-			if (LLWearableDictionary::getAssetType((EWearableType)type) == LLAssetType::AT_CLOTHING)
+			if (LLWearableType::getAssetType((LLWearableType::EType)type) == LLAssetType::AT_CLOTHING)
 			{
-				removeWearable((EWearableType)type, true, 0);
+				removeWearable((LLWearableType::EType)type, true, 0);
 			}
 		}
 	}
@@ -1537,12 +1537,12 @@ void LLAgentWearables::setWearableOutfit(const LLInventoryItem::item_array_t& it
 		llassert(new_wearable);
 		if (new_wearable)
 		{
-			const EWearableType type = new_wearable->getType();
+			const LLWearableType::EType type = new_wearable->getType();
 		
 			new_wearable->setName(new_item->getName());
 			new_wearable->setItemID(new_item->getUUID());
 
-			if (LLWearableDictionary::getAssetType(type) == LLAssetType::AT_BODYPART)
+			if (LLWearableType::getAssetType(type) == LLAssetType::AT_BODYPART)
 			{
 				// exactly one wearable per body part
 				setWearable(type,0,new_wearable);
@@ -1586,7 +1586,7 @@ void LLAgentWearables::setWearableItem(LLInventoryItem* new_item, LLWearable* ne
 		return;
 	}
 	
-	const EWearableType type = new_wearable->getType();
+	const LLWearableType::EType type = new_wearable->getType();
 
 	if (!do_append)
 	{
@@ -1599,7 +1599,7 @@ void LLAgentWearables::setWearableItem(LLInventoryItem* new_item, LLWearable* ne
 			if ((old_wearable->getAssetID() == new_wearable->getAssetID()) &&
 				(old_item_id == new_item->getUUID()))
 			{
-				lldebugs << "No change to wearable asset and item: " << LLWearableDictionary::getInstance()->getWearableEntry(type) << llendl;
+				lldebugs << "No change to wearable asset and item: " << LLWearableType::getTypeName(type) << llendl;
 				return;
 			}
 			
@@ -1656,7 +1656,7 @@ bool LLAgentWearables::onSetWearableDialog(const LLSD& notification, const LLSD&
 // MULTI_WEARABLE: unify code after null objects are gone.
 void LLAgentWearables::setWearableFinal(LLInventoryItem* new_item, LLWearable* new_wearable, bool do_append)
 {
-	const EWearableType type = new_wearable->getType();
+	const LLWearableType::EType type = new_wearable->getType();
 
 	if (do_append && getWearableItemID(type,0).notNull())
 	{
@@ -1726,7 +1726,7 @@ void LLAgentWearables::queryWearableCache()
 		bool hash_computed = false;
 		for (U8 i=0; i < baked_dict->mWearables.size(); i++)
 		{
-			const EWearableType baked_type = baked_dict->mWearables[i];
+			const LLWearableType::EType baked_type = baked_dict->mWearables[i];
 			const U32 num_wearables = getWearableCount(baked_type);
 			for (U32 index = 0; index < num_wearables; ++index)
 			{
@@ -1765,20 +1765,20 @@ void LLAgentWearables::queryWearableCache()
 
 // User has picked "remove from avatar" from a menu.
 // static
-void LLAgentWearables::userRemoveWearable(const EWearableType &type, const U32 &index)
+void LLAgentWearables::userRemoveWearable(const LLWearableType::EType &type, const U32 &index)
 {
-	if (!(type==WT_SHAPE || type==WT_SKIN || type==WT_HAIR || type==WT_EYES)) //&&
-		//!((!gAgent.isTeen()) && (type==WT_UNDERPANTS || type==WT_UNDERSHIRT)))
+	if (!(type==LLWearableType::WT_SHAPE || type==LLWearableType::WT_SKIN || type==LLWearableType::WT_HAIR || type==LLWearableType::WT_EYES)) //&&
+		//!((!gAgent.isTeen()) && (type==LLWearableType::WT_UNDERPANTS || type==LLWearableType::WT_UNDERSHIRT)))
 	{
 		gAgentWearables.removeWearable(type,false,index);
 	}
 }
 
 //static 
-void LLAgentWearables::userRemoveWearablesOfType(const EWearableType &type)
+void LLAgentWearables::userRemoveWearablesOfType(const LLWearableType::EType &type)
 {
-	if (!(type==WT_SHAPE || type==WT_SKIN || type==WT_HAIR || type==WT_EYES)) //&&
-		//!((!gAgent.isTeen()) && (type==WT_UNDERPANTS || type==WT_UNDERSHIRT)))
+	if (!(type==LLWearableType::WT_SHAPE || type==LLWearableType::WT_SKIN || type==LLWearableType::WT_HAIR || type==LLWearableType::WT_EYES)) //&&
+		//!((!gAgent.isTeen()) && (type==LLWearableType::WT_UNDERPANTS || type==LLWearableType::WT_UNDERSHIRT)))
 	{
 		gAgentWearables.removeWearable(type,true,0);
 	}
@@ -1803,17 +1803,17 @@ void LLAgentWearables::userRemoveAllClothesStep2(BOOL proceed)
 {
 	if (proceed)
 	{
-		gAgentWearables.removeWearable(WT_SHIRT,true,0);
-		gAgentWearables.removeWearable(WT_PANTS,true,0);
-		gAgentWearables.removeWearable(WT_SHOES,true,0);
-		gAgentWearables.removeWearable(WT_SOCKS,true,0);
-		gAgentWearables.removeWearable(WT_JACKET,true,0);
-		gAgentWearables.removeWearable(WT_GLOVES,true,0);
-		gAgentWearables.removeWearable(WT_UNDERSHIRT,true,0);
-		gAgentWearables.removeWearable(WT_UNDERPANTS,true,0);
-		gAgentWearables.removeWearable(WT_SKIRT,true,0);
-		gAgentWearables.removeWearable(WT_ALPHA,true,0);
-		gAgentWearables.removeWearable(WT_TATTOO,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_SHIRT,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_PANTS,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_SHOES,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_SOCKS,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_JACKET,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_GLOVES,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_UNDERSHIRT,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_UNDERPANTS,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_SKIRT,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_ALPHA,true,0);
+		gAgentWearables.removeWearable(LLWearableType::WT_TATTOO,true,0);
 	}
 }
 
@@ -2024,18 +2024,18 @@ bool LLAgentWearables::canWearableBeRemoved(const LLWearable* wearable) const
 {
 	if (!wearable) return false;
 	
-	EWearableType type = wearable->getType();
+	LLWearableType::EType type = wearable->getType();
 	// Make sure the user always has at least one shape, skin, eyes, and hair type currently worn.
-	return !(((type == WT_SHAPE) || (type == WT_SKIN) || (type == WT_HAIR) || (type == WT_EYES))
+	return !(((type == LLWearableType::WT_SHAPE) || (type == LLWearableType::WT_SKIN) || (type == LLWearableType::WT_HAIR) || (type == LLWearableType::WT_EYES))
 			 && (getWearableCount(type) <= 1) );		  
 }
 void LLAgentWearables::animateAllWearableParams(F32 delta, BOOL upload_bake)
 {
-	for( S32 type = 0; type < WT_COUNT; ++type )
+	for( S32 type = 0; type < LLWearableType::WT_COUNT; ++type )
 	{
-		for (S32 count = 0; count < (S32)getWearableCount((EWearableType)type); ++count)
+		for (S32 count = 0; count < (S32)getWearableCount((LLWearableType::EType)type); ++count)
 		{
-			LLWearable *wearable = getWearable((EWearableType)type,count);
+			LLWearable *wearable = getWearable((LLWearableType::EType)type,count);
 			wearable->animateParams(delta, upload_bake);
 		}
 	}
diff --git a/indra/newview/llagentwearables.h b/indra/newview/llagentwearables.h
index a28cba0343..def16e4e85 100644
--- a/indra/newview/llagentwearables.h
+++ b/indra/newview/llagentwearables.h
@@ -71,8 +71,8 @@ protected:
 	//--------------------------------------------------------------------
 public:
 	BOOL			isWearingItem(const LLUUID& item_id) const;
-	BOOL			isWearableModifiable(EWearableType type, U32 index /*= 0*/) const;
-	BOOL			isWearableCopyable(EWearableType type, U32 index /*= 0*/) const;
+	BOOL			isWearableModifiable(LLWearableType::EType type, U32 index /*= 0*/) const;
+	BOOL			isWearableCopyable(LLWearableType::EType type, U32 index /*= 0*/) const;
 	BOOL			areWearablesLoaded() const;
 	void			updateWearablesLoaded();
 	void			checkWearablesLoaded() const;
@@ -88,17 +88,17 @@ public:
 	// Accessors
 	//--------------------------------------------------------------------
 public:
-	const LLUUID		getWearableItemID(EWearableType type, U32 index /*= 0*/) const;
-	const LLUUID		getWearableAssetID(EWearableType type, U32 index /*= 0*/) const;
+	const LLUUID		getWearableItemID(LLWearableType::EType type, U32 index /*= 0*/) const;
+	const LLUUID		getWearableAssetID(LLWearableType::EType type, U32 index /*= 0*/) const;
 	const LLWearable*	getWearableFromItemID(const LLUUID& item_id) const;
 	LLWearable*	getWearableFromAssetID(const LLUUID& asset_id);
-	LLInventoryItem*	getWearableInventoryItem(EWearableType type, U32 index /*= 0*/);
+	LLInventoryItem*	getWearableInventoryItem(LLWearableType::EType type, U32 index /*= 0*/);
 	// MULTI-WEARABLE: assuming one per type.
-	static BOOL			selfHasWearable(EWearableType type);
-	LLWearable*			getWearable(const EWearableType type, U32 index /*= 0*/); 
-	const LLWearable* 	getWearable(const EWearableType type, U32 index /*= 0*/) const;
-	LLWearable*		getTopWearable(const EWearableType type);
-	U32				getWearableCount(const EWearableType type) const;
+	static BOOL			selfHasWearable(LLWearableType::EType type);
+	LLWearable*			getWearable(const LLWearableType::EType type, U32 index /*= 0*/); 
+	const LLWearable* 	getWearable(const LLWearableType::EType type, U32 index /*= 0*/) const;
+	LLWearable*		getTopWearable(const LLWearableType::EType type);
+	U32				getWearableCount(const LLWearableType::EType type) const;
 	U32				getWearableCount(const U32 tex_index) const;
 
 	//--------------------------------------------------------------------
@@ -107,17 +107,17 @@ public:
 
 private:
 	// Low-level data structure setter - public access is via setWearableItem, etc.
-	void 			setWearable(const EWearableType type, U32 index, LLWearable *wearable);
-	U32 			pushWearable(const EWearableType type, LLWearable *wearable);
+	void 			setWearable(const LLWearableType::EType type, U32 index, LLWearable *wearable);
+	U32 			pushWearable(const LLWearableType::EType type, LLWearable *wearable);
 	void			wearableUpdated(LLWearable *wearable);
 	void 			popWearable(LLWearable *wearable);
-	void			popWearable(const EWearableType type, U32 index);
+	void			popWearable(const LLWearableType::EType type, U32 index);
 	
 public:
 	void			setWearableItem(LLInventoryItem* new_item, LLWearable* wearable, bool do_append = false);
 	void			setWearableOutfit(const LLInventoryItem::item_array_t& items, const LLDynamicArray< LLWearable* >& wearables, BOOL remove);
 	void			setWearableName(const LLUUID& item_id, const std::string& new_name);
-	void			addLocalTextureObject(const EWearableType wearable_type, const LLVOAvatarDefines::ETextureIndex texture_type, U32 wearable_index);
+	void			addLocalTextureObject(const LLWearableType::EType wearable_type, const LLVOAvatarDefines::ETextureIndex texture_type, U32 wearable_index);
 	U32				getWearableIndex(LLWearable *wearable);
 
 protected:
@@ -132,16 +132,16 @@ protected:
 													const U32 index,
 													const LLUUID& item_id,
 													LLWearable* wearable);
-	void			recoverMissingWearable(const EWearableType type, U32 index /*= 0*/);
+	void			recoverMissingWearable(const LLWearableType::EType type, U32 index /*= 0*/);
 	void			recoverMissingWearableDone();
 
 	//--------------------------------------------------------------------
 	// Removing wearables
 	//--------------------------------------------------------------------
 public:
-	void			removeWearable(const EWearableType type, bool do_remove_all /*= false*/, U32 index /*= 0*/);
+	void			removeWearable(const LLWearableType::EType type, bool do_remove_all /*= false*/, U32 index /*= 0*/);
 private:
-	void			removeWearableFinal(const EWearableType type, bool do_remove_all /*= false*/, U32 index /*= 0*/);
+	void			removeWearableFinal(const LLWearableType::EType type, bool do_remove_all /*= false*/, U32 index /*= 0*/);
 protected:
 	static bool		onRemoveWearableDialog(const LLSD& notification, const LLSD& response);
 	static void		userRemoveAllClothesStep2(BOOL proceed); // userdata is NULL
@@ -165,7 +165,7 @@ protected:
 public:
 	void 			getAllWearablesArray(LLDynamicArray<S32>& wearables);
 	
-	// Note:	wearables_to_include should be a list of EWearableType types
+	// Note:	wearables_to_include should be a list of LLWearableType::EType types
 	//			attachments_to_include should be a list of attachment points
 	void			makeNewOutfit(const std::string& new_folder_name,
 								  const LLDynamicArray<S32>& wearables_to_include,
@@ -185,17 +185,17 @@ private:
 	//--------------------------------------------------------------------
 public:	
     // MULTI-WEARABLE: assumes one per type.
-	void			saveWearableAs(const EWearableType type, const U32 index, const std::string& new_name, BOOL save_in_lost_and_found);
-	void			saveWearable(const EWearableType type, const U32 index, BOOL send_update = TRUE);
+	void			saveWearableAs(const LLWearableType::EType type, const U32 index, const std::string& new_name, BOOL save_in_lost_and_found);
+	void			saveWearable(const LLWearableType::EType type, const U32 index, BOOL send_update = TRUE);
 	void			saveAllWearables();
-	void			revertWearable(const EWearableType type, const U32 index);
+	void			revertWearable(const LLWearableType::EType type, const U32 index);
 
 	//--------------------------------------------------------------------
 	// Static UI hooks
 	//--------------------------------------------------------------------
 public:
-	static void		userRemoveWearable(const EWearableType &type, const U32 &index);
-	static void		userRemoveWearablesOfType(const EWearableType &type);
+	static void		userRemoveWearable(const LLWearableType::EType &type, const U32 &index);
+	static void		userRemoveWearablesOfType(const LLWearableType::EType &type);
 	static void		userRemoveAllClothes();	
 	
 	typedef std::vector<LLViewerObject*> llvo_vec_t;
@@ -224,7 +224,7 @@ private:
 	//--------------------------------------------------------------------
 private:
 	typedef std::vector<LLWearable*> wearableentry_vec_t; // all wearables of a certain type (EG all shirts)
-	typedef std::map<EWearableType, wearableentry_vec_t> wearableentry_map_t;	// wearable "categories" arranged by wearable type
+	typedef std::map<LLWearableType::EType, wearableentry_vec_t> wearableentry_map_t;	// wearable "categories" arranged by wearable type
 	wearableentry_map_t mWearableDatas;
 
 	static BOOL		mInitialWearablesUpdateReceived;
@@ -259,7 +259,7 @@ private:
 			CALL_WEARITEM = 16
 		};
 
-		// MULTI-WEARABLE: index is an EWearableType - more confusing usage.
+		// MULTI-WEARABLE: index is an LLWearableType::EType - more confusing usage.
 		// MULTI-WEARABLE: need to have type and index args both?
 		addWearableToAgentInventoryCallback(LLPointer<LLRefCount> cb,
 											S32 type,
diff --git a/indra/newview/llagentwearablesfetch.h b/indra/newview/llagentwearablesfetch.h
index 6695727d46..58b92a5747 100644
--- a/indra/newview/llagentwearablesfetch.h
+++ b/indra/newview/llagentwearablesfetch.h
@@ -53,10 +53,10 @@ public:
 
 	struct InitialWearableData
 	{
-		EWearableType mType;
+		LLWearableType::EType mType;
 		LLUUID mItemID;
 		LLUUID mAssetID;
-		InitialWearableData(EWearableType type, LLUUID& itemID, LLUUID& assetID) :
+		InitialWearableData(LLWearableType::EType type, LLUUID& itemID, LLUUID& assetID) :
 			mType(type),
 			mItemID(itemID),
 			mAssetID(assetID)
diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index e93e29ecde..80e8b94ccc 100644
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -137,7 +137,7 @@ public:
 class LLFindClothesOfType : public LLInventoryCollectFunctor
 {
 public:
-	LLFindClothesOfType(EWearableType type) : mWearableType(type) {}
+	LLFindClothesOfType(LLWearableType::EType type) : mWearableType(type) {}
 	virtual ~LLFindClothesOfType() {}
 	virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
 	{
@@ -150,7 +150,7 @@ public:
 		return true;
 	}
 
-	const EWearableType mWearableType;
+	const LLWearableType::EType mWearableType;
 };
 
 
@@ -179,14 +179,14 @@ struct LLFoundData
 {
 	LLFoundData() :
 		mAssetType(LLAssetType::AT_NONE),
-		mWearableType(WT_INVALID),
+		mWearableType(LLWearableType::WT_NONE),
 		mWearable(NULL) {}
 
 	LLFoundData(const LLUUID& item_id,
 				const LLUUID& asset_id,
 				const std::string& name,
 				const LLAssetType::EType& asset_type,
-				const EWearableType& wearable_type
+				const LLWearableType::EType& wearable_type
 		) :
 		mItemID(item_id),
 		mAssetID(asset_id),
@@ -199,7 +199,7 @@ struct LLFoundData
 	LLUUID mAssetID;
 	std::string mName;
 	LLAssetType::EType mAssetType;
-	EWearableType mWearableType;
+	LLWearableType::EType mWearableType;
 	LLWearable* mWearable;
 };
 
@@ -218,7 +218,7 @@ public:
 	void checkMissingWearables();
 	bool pollMissingWearables();
 	bool isMissingCompleted();
-	void recoverMissingWearable(EWearableType type);
+	void recoverMissingWearable(LLWearableType::EType type);
 	void clearCOFLinksForMissingWearables();
 	
 	void onWearableAssetFetch(LLWearable *wearable);
@@ -259,18 +259,18 @@ bool LLWearableHoldingPattern::isTimedOut()
 
 void LLWearableHoldingPattern::checkMissingWearables()
 {
-	std::vector<S32> found_by_type(WT_COUNT,0);
-	std::vector<S32> requested_by_type(WT_COUNT,0);
+	std::vector<S32> found_by_type(LLWearableType::WT_COUNT,0);
+	std::vector<S32> requested_by_type(LLWearableType::WT_COUNT,0);
 	for (found_list_t::iterator it = mFoundList.begin(); it != mFoundList.end(); ++it)
 	{
 		LLFoundData &data = *it;
-		if (data.mWearableType < WT_COUNT)
+		if (data.mWearableType < LLWearableType::WT_COUNT)
 			requested_by_type[data.mWearableType]++;
 		if (data.mWearable)
 			found_by_type[data.mWearableType]++;
 	}
 
-	for (S32 type = 0; type < WT_COUNT; ++type)
+	for (S32 type = 0; type < LLWearableType::WT_COUNT; ++type)
 	{
 		llinfos << "type " << type << " requested " << requested_by_type[type] << " found " << found_by_type[type] << llendl;
 		if (found_by_type[type] > 0)
@@ -281,11 +281,11 @@ void LLWearableHoldingPattern::checkMissingWearables()
 			// pants)
 			(requested_by_type[type] > 0) ||  
 			// or if type is a body part and no wearables were found.
-			((type == WT_SHAPE) || (type == WT_SKIN) || (type == WT_HAIR) || (type == WT_EYES)))
+			((type == LLWearableType::WT_SHAPE) || (type == LLWearableType::WT_SKIN) || (type == LLWearableType::WT_HAIR) || (type == LLWearableType::WT_EYES)))
 		{
 			mTypesToRecover.insert(type);
 			mTypesToLink.insert(type);
-			recoverMissingWearable((EWearableType)type);
+			recoverMissingWearable((LLWearableType::EType)type);
 			llwarns << "need to replace " << type << llendl; 
 		}
 	}
@@ -368,7 +368,7 @@ bool LLWearableHoldingPattern::pollFetchCompletion()
 class RecoveredItemLinkCB: public LLInventoryCallback
 {
 public:
-	RecoveredItemLinkCB(EWearableType type, LLWearable *wearable, LLWearableHoldingPattern* holder):
+	RecoveredItemLinkCB(LLWearableType::EType type, LLWearable *wearable, LLWearableHoldingPattern* holder):
 		mHolder(holder),
 		mWearable(wearable),
 		mType(type)
@@ -392,7 +392,7 @@ public:
 						  linked_item->getAssetUUID(),
 						  linked_item->getName(),
 						  linked_item->getType(),
-						  linked_item->isWearableType() ? linked_item->getWearableType() : WT_INVALID
+						  linked_item->isWearableType() ? linked_item->getWearableType() : LLWearableType::WT_NONE
 						  );
 				found.mWearable = mWearable;
 				mHolder->mFoundList.push_front(found);
@@ -410,13 +410,13 @@ public:
 private:
 	LLWearableHoldingPattern* mHolder;
 	LLWearable *mWearable;
-	EWearableType mType;
+	LLWearableType::EType mType;
 };
 
 class RecoveredItemCB: public LLInventoryCallback
 {
 public:
-	RecoveredItemCB(EWearableType type, LLWearable *wearable, LLWearableHoldingPattern* holder):
+	RecoveredItemCB(LLWearableType::EType type, LLWearable *wearable, LLWearableHoldingPattern* holder):
 		mHolder(holder),
 		mWearable(wearable),
 		mType(type)
@@ -444,14 +444,14 @@ public:
 private:
 	LLWearableHoldingPattern* mHolder;
 	LLWearable *mWearable;
-	EWearableType mType;
+	LLWearableType::EType mType;
 };
 
-void LLWearableHoldingPattern::recoverMissingWearable(EWearableType type)
+void LLWearableHoldingPattern::recoverMissingWearable(LLWearableType::EType type)
 {
 		// Try to recover by replacing missing wearable with a new one.
 	LLNotificationsUtil::add("ReplacedMissingWearable");
-	lldebugs << "Wearable " << LLWearableDictionary::getTypeLabel(type)
+	lldebugs << "Wearable " << LLWearableType::getTypeLabel(type)
 			 << " could not be downloaded.  Replaced inventory item with default wearable." << llendl;
 	LLWearable* wearable = LLWearableList::instance().createNewWearable(type);
 
@@ -482,7 +482,7 @@ void LLWearableHoldingPattern::clearCOFLinksForMissingWearables()
 	for (found_list_t::iterator it = mFoundList.begin(); it != mFoundList.end(); ++it)
 	{
 		LLFoundData &data = *it;
-		if ((data.mWearableType < WT_COUNT) && (!data.mWearable))
+		if ((data.mWearableType < LLWearableType::WT_COUNT) && (!data.mWearable))
 		{
 			// Wearable link that was never resolved; remove links to it from COF
 			llinfos << "removing link for unresolved item " << data.mItemID.asString() << llendl;
@@ -543,7 +543,7 @@ void LLWearableHoldingPattern::onWearableAssetFetch(LLWearable *wearable)
 		{
 			data.mWearable = wearable;
 			// Failing this means inventory or asset server are corrupted in a way we don't handle.
-			llassert((data.mWearableType < WT_COUNT) && (wearable->getType() == data.mWearableType));
+			llassert((data.mWearableType < LLWearableType::WT_COUNT) && (wearable->getType() == data.mWearableType));
 			break;
 		}
 	}
@@ -778,10 +778,10 @@ BOOL LLAppearanceMgr::getCanMakeFolderIntoOutfit(const LLUUID& folder_id)
 	// These are the wearable items that are required for considering this
 	// folder as containing a complete outfit.
 	U32 required_wearables = 0;
-	required_wearables |= 1LL << WT_SHAPE;
-	required_wearables |= 1LL << WT_SKIN;
-	required_wearables |= 1LL << WT_HAIR;
-	required_wearables |= 1LL << WT_EYES;
+	required_wearables |= 1LL << LLWearableType::WT_SHAPE;
+	required_wearables |= 1LL << LLWearableType::WT_SKIN;
+	required_wearables |= 1LL << LLWearableType::WT_HAIR;
+	required_wearables |= 1LL << LLWearableType::WT_EYES;
 
 	// These are the wearables that the folder actually contains.
 	U32 folder_wearables = 0;
@@ -795,7 +795,7 @@ BOOL LLAppearanceMgr::getCanMakeFolderIntoOutfit(const LLUUID& folder_id)
 		const LLViewerInventoryItem* item = (*iter);
 		if (item->isWearableType())
 		{
-			const EWearableType wearable_type = item->getWearableType();
+			const LLWearableType::EType wearable_type = item->getWearableType();
 			folder_wearables |= 1LL << wearable_type;
 		}
 	}
@@ -851,12 +851,12 @@ void LLAppearanceMgr::filterWearableItems(
 	LLInventoryModel::item_array_t& items, S32 max_per_type)
 {
 	// Divvy items into arrays by wearable type.
-	std::vector<LLInventoryModel::item_array_t> items_by_type(WT_COUNT);
+	std::vector<LLInventoryModel::item_array_t> items_by_type(LLWearableType::WT_COUNT);
 	divvyWearablesByType(items, items_by_type);
 
 	// rebuild items list, retaining the last max_per_type of each array
 	items.clear();
-	for (S32 i=0; i<WT_COUNT; i++)
+	for (S32 i=0; i<LLWearableType::WT_COUNT; i++)
 	{
 		S32 size = items_by_type[i].size();
 		if (size <= 0)
@@ -1001,7 +1001,7 @@ void LLAppearanceMgr::updateAgentWearables(LLWearableHoldingPattern* holder, boo
 
 	// For each wearable type, find the first instance in the category
 	// that we recursed through.
-	for( S32 i = 0; i < WT_COUNT; i++ )
+	for( S32 i = 0; i < LLWearableType::WT_COUNT; i++ )
 	{
 		for (LLWearableHoldingPattern::found_list_t::iterator iter = holder->mFoundList.begin();
 			 iter != holder->mFoundList.end(); ++iter)
@@ -1115,14 +1115,14 @@ void LLAppearanceMgr::updateAppearanceFromCOF()
 							  linked_item->getAssetUUID(),
 							  linked_item->getName(),
 							  linked_item->getType(),
-							  linked_item->isWearableType() ? linked_item->getWearableType() : WT_INVALID
+							  linked_item->isWearableType() ? linked_item->getWearableType() : LLWearableType::WT_NONE
 				);
 
 #if 0
 			// Fault injection: uncomment this block to test asset
 			// fetch failures (should be replaced by new defaults in
 			// lost&found).
-			if (found.mWearableType == WT_SHAPE || found.mWearableType == WT_JACKET)
+			if (found.mWearableType == LLWearableType::WT_SHAPE || found.mWearableType == LLWearableType::WT_JACKET)
 			{
 				found.mAssetID.generate(); // Replace with new UUID, guaranteed not to exist in DB
 				
@@ -1654,7 +1654,7 @@ bool LLAppearanceMgr::updateBaseOutfit()
 
 void LLAppearanceMgr::divvyWearablesByType(const LLInventoryModel::item_array_t& items, wearables_by_type_t& items_by_type)
 {
-	items_by_type.reserve(WT_COUNT);
+	items_by_type.reserve(LLWearableType::WT_COUNT);
 	if (items.empty()) return;
 
 	for (S32 i=0; i<items.count(); i++)
@@ -1663,8 +1663,8 @@ void LLAppearanceMgr::divvyWearablesByType(const LLInventoryModel::item_array_t&
 		// Ignore non-wearables.
 		if (!item->isWearableType())
 			continue;
-		EWearableType type = item->getWearableType();
-		if(type < 0 || type >= WT_COUNT)
+		LLWearableType::EType type = item->getWearableType();
+		if(type < 0 || type >= LLWearableType::WT_COUNT)
 		{
 			LL_WARNS("Appearance") << "Invalid wearable type. Inventory type does not match wearable flag bitfield." << LL_ENDL;
 			continue;
@@ -1673,7 +1673,7 @@ void LLAppearanceMgr::divvyWearablesByType(const LLInventoryModel::item_array_t&
 	}
 }
 
-std::string build_order_string(EWearableType type, U32 i)
+std::string build_order_string(LLWearableType::EType type, U32 i)
 {
 		std::ostringstream order_num;
 		order_num << ORDER_NUMBER_SEPARATOR << type * 100 + i;
@@ -1682,7 +1682,7 @@ std::string build_order_string(EWearableType type, U32 i)
 
 struct WearablesOrderComparator
 {
-	WearablesOrderComparator(const EWearableType type)
+	WearablesOrderComparator(const LLWearableType::EType type)
 	{
 		mControlSize = build_order_string(type, 0).size();
 	};
@@ -1720,18 +1720,18 @@ void LLAppearanceMgr::updateClothingOrderingInfo()
 	LLInventoryModel::item_array_t wear_items;
 	getDescendentsOfAssetType(getCOF(), wear_items, LLAssetType::AT_CLOTHING, false);
 
-	wearables_by_type_t items_by_type(WT_COUNT);
+	wearables_by_type_t items_by_type(LLWearableType::WT_COUNT);
 	divvyWearablesByType(wear_items, items_by_type);
 
 	bool inventory_changed = false;
-	for (U32 type = WT_SHIRT; type < WT_COUNT; type++)
+	for (U32 type = LLWearableType::WT_SHIRT; type < LLWearableType::WT_COUNT; type++)
 	{
 		
 		U32 size = items_by_type[type].size();
 		if (!size) continue;
 
 		//sinking down invalid items which need reordering
-		std::sort(items_by_type[type].begin(), items_by_type[type].end(), WearablesOrderComparator((EWearableType) type));
+		std::sort(items_by_type[type].begin(), items_by_type[type].end(), WearablesOrderComparator((LLWearableType::EType) type));
 
 		//requesting updates only for those links which don't have "valid" descriptions
 		for (U32 i = 0; i < size; i++)
@@ -1739,7 +1739,7 @@ void LLAppearanceMgr::updateClothingOrderingInfo()
 			LLViewerInventoryItem* item = items_by_type[type][i];
 			if (!item) continue;
 
-			std::string new_order_str = build_order_string((EWearableType)type, i);
+			std::string new_order_str = build_order_string((LLWearableType::EType)type, i);
 			if (new_order_str == item->LLInventoryItem::getDescription()) continue;
 
 			item->setDescription(new_order_str);
diff --git a/indra/newview/llcofwearables.cpp b/indra/newview/llcofwearables.cpp
index 29c32b6fa2..c73aa5f415 100644
--- a/indra/newview/llcofwearables.cpp
+++ b/indra/newview/llcofwearables.cpp
@@ -114,7 +114,7 @@ void LLCOFWearables::refresh()
 	populateAttachmentsAndBodypartsLists(cof_items);
 
 
-	LLAppearanceMgr::wearables_by_type_t clothing_by_type(WT_COUNT);
+	LLAppearanceMgr::wearables_by_type_t clothing_by_type(LLWearableType::WT_COUNT);
 	LLAppearanceMgr::getInstance()->divvyWearablesByType(cof_items, clothing_by_type);
 	
 	populateClothingList(clothing_by_type);
@@ -234,9 +234,9 @@ LLPanelBodyPartsListItem* LLCOFWearables::buildBodypartListItem(LLViewerInventor
 
 void LLCOFWearables::populateClothingList(LLAppearanceMgr::wearables_by_type_t& clothing_by_type)
 {
-	llassert(clothing_by_type.size() == WT_COUNT);
+	llassert(clothing_by_type.size() == LLWearableType::WT_COUNT);
 
-	for (U32 type = WT_SHIRT; type < WT_COUNT; ++type)
+	for (U32 type = LLWearableType::WT_SHIRT; type < LLWearableType::WT_COUNT; ++type)
 	{
 		U32 size = clothing_by_type[type].size();
 		if (!size) continue;
@@ -263,14 +263,14 @@ void LLCOFWearables::populateClothingList(LLAppearanceMgr::wearables_by_type_t&
 //adding dummy items for missing wearable types
 void LLCOFWearables::addClothingTypesDummies(const LLAppearanceMgr::wearables_by_type_t& clothing_by_type)
 {
-	llassert(clothing_by_type.size() == WT_COUNT);
+	llassert(clothing_by_type.size() == LLWearableType::WT_COUNT);
 	
-	for (U32 type = WT_SHIRT; type < WT_COUNT; type++)
+	for (U32 type = LLWearableType::WT_SHIRT; type < LLWearableType::WT_COUNT; type++)
 	{
 		U32 size = clothing_by_type[type].size();
 		if (size) continue;
 
-		EWearableType w_type = static_cast<EWearableType>(type);
+		LLWearableType::EType w_type = static_cast<LLWearableType::EType>(type);
 		LLPanelInventoryListItemBase* item_panel = LLPanelDummyClothingListItem::create(w_type);
 		if(!item_panel) continue;
 		mClothing->addItem(item_panel, LLUUID::null, ADD_BOTTOM, false);
diff --git a/indra/newview/lldriverparam.cpp b/indra/newview/lldriverparam.cpp
index ebd767d654..40ce0ebcf4 100644
--- a/indra/newview/lldriverparam.cpp
+++ b/indra/newview/lldriverparam.cpp
@@ -534,7 +534,7 @@ void LLDriverParam::resetDrivenParams()
 	mDriven.reserve(getInfo()->mDrivenInfoList.size());
 }
 
-void LLDriverParam::updateCrossDrivenParams(EWearableType driven_type)
+void LLDriverParam::updateCrossDrivenParams(LLWearableType::EType driven_type)
 {
 	bool needs_update = (getWearableType()==driven_type);
 
@@ -551,7 +551,7 @@ void LLDriverParam::updateCrossDrivenParams(EWearableType driven_type)
 
 	if (needs_update)
 	{
-		EWearableType driver_type = (EWearableType)getWearableType();
+		LLWearableType::EType driver_type = (LLWearableType::EType)getWearableType();
 		
 		// If we've gotten here, we've added a new wearable of type "type"
 		// Thus this wearable needs to get updates from the driver wearable.
diff --git a/indra/newview/lldriverparam.h b/indra/newview/lldriverparam.h
index e963a2d55a..2b79c18873 100644
--- a/indra/newview/lldriverparam.h
+++ b/indra/newview/lldriverparam.h
@@ -94,7 +94,7 @@ public:
 
 	void					setWearable(LLWearable *wearablep);
 	void					setAvatar(LLVOAvatar *avatarp);
-	void					updateCrossDrivenParams(EWearableType driven_type);
+	void					updateCrossDrivenParams(LLWearableType::EType driven_type);
 
 	/*virtual*/ LLViewerVisualParam* cloneParam(LLWearable* wearable) const;
 
diff --git a/indra/newview/llfloateravatartextures.cpp b/indra/newview/llfloateravatartextures.cpp
index deef85cc6c..fd392d949a 100644
--- a/indra/newview/llfloateravatartextures.cpp
+++ b/indra/newview/llfloateravatartextures.cpp
@@ -84,7 +84,7 @@ static void update_texture_ctrl(LLVOAvatar* avatarp,
 	{
 		if (avatarp->isSelf())
 		{
-			const EWearableType wearable_type = tex_entry->mWearableType;
+			const LLWearableType::EType wearable_type = tex_entry->mWearableType;
 			LLWearable *wearable = gAgentWearables.getWearable(wearable_type, 0);
 			if (wearable)
 			{
@@ -175,7 +175,7 @@ void LLFloaterAvatarTextures::onClickDump(void* data)
 			if (LLVOAvatar::isIndexLocalTexture((ETextureIndex)i))
 			{
 				LLUUID id = IMG_DEFAULT_AVATAR;
-				EWearableType wearable_type = LLVOAvatarDictionary::getInstance()->getTEWearableType((ETextureIndex)i);
+				LLWearableType::EType wearable_type = LLVOAvatarDictionary::getInstance()->getTEWearableType((ETextureIndex)i);
 				if (avatarp->isSelf())
 				{
 					LLWearable *wearable = gAgentWearables.getWearable(wearable_type, 0);
diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index 67de5e8573..64379f4ce7 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -951,7 +951,7 @@ LLInvFVBridge* LLInvFVBridge::createBridge(LLAssetType::EType asset_type,
 			{
 				llwarns << LLAssetType::lookup(asset_type) << " asset has inventory type " << LLInventoryType::lookupHumanReadable(inv_type) << " on uuid " << uuid << llendl;
 			}
-			new_listener = new LLWearableBridge(inventory, root, uuid, asset_type, inv_type, (EWearableType)flags);
+			new_listener = new LLWearableBridge(inventory, root, uuid, asset_type, inv_type, (LLWearableType::EType)flags);
 			break;
 		case LLAssetType::AT_CATEGORY:
 			if (actual_asset_type == LLAssetType::AT_LINK_FOLDER)
@@ -2943,71 +2943,71 @@ void LLFolderBridge::createNewCategory(void* user_data)
 
 void LLFolderBridge::createNewShirt(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_SHIRT);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_SHIRT);
 }
 
 void LLFolderBridge::createNewPants(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_PANTS);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_PANTS);
 }
 
 void LLFolderBridge::createNewShoes(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_SHOES);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_SHOES);
 }
 
 void LLFolderBridge::createNewSocks(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_SOCKS);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_SOCKS);
 }
 
 void LLFolderBridge::createNewJacket(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_JACKET);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_JACKET);
 }
 
 void LLFolderBridge::createNewSkirt(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_SKIRT);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_SKIRT);
 }
 
 void LLFolderBridge::createNewGloves(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_GLOVES);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_GLOVES);
 }
 
 void LLFolderBridge::createNewUndershirt(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_UNDERSHIRT);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_UNDERSHIRT);
 }
 
 void LLFolderBridge::createNewUnderpants(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_UNDERPANTS);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_UNDERPANTS);
 }
 
 void LLFolderBridge::createNewShape(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_SHAPE);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_SHAPE);
 }
 
 void LLFolderBridge::createNewSkin(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_SKIN);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_SKIN);
 }
 
 void LLFolderBridge::createNewHair(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_HAIR);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_HAIR);
 }
 
 void LLFolderBridge::createNewEyes(void* user_data)
 {
-	LLFolderBridge::createWearable((LLFolderBridge*)user_data, WT_EYES);
+	LLFolderBridge::createWearable((LLFolderBridge*)user_data, LLWearableType::WT_EYES);
 }
 
 // static
-void LLFolderBridge::createWearable(LLFolderBridge* bridge, EWearableType type)
+void LLFolderBridge::createWearable(LLFolderBridge* bridge, LLWearableType::EType type)
 {
 	if(!bridge) return;
 	LLUUID parent_id = bridge->getUUID();
@@ -3017,7 +3017,7 @@ void LLFolderBridge::createWearable(LLFolderBridge* bridge, EWearableType type)
 // Separate function so can be called by global menu as well as right-click
 // menu.
 // static
-void LLFolderBridge::createWearable(const LLUUID &parent_id, EWearableType type)
+void LLFolderBridge::createWearable(const LLUUID &parent_id, LLWearableType::EType type)
 {
 	LLWearable* wearable = LLWearableList::instance().createNewWearable(type);
 	LLAssetType::EType asset_type = wearable->getAssetType();
@@ -4444,7 +4444,7 @@ LLWearableBridge::LLWearableBridge(LLInventoryPanel* inventory,
 								   const LLUUID& uuid, 
 								   LLAssetType::EType asset_type, 
 								   LLInventoryType::EType inv_type, 
-								   EWearableType  wearable_type) :
+								   LLWearableType::EType  wearable_type) :
 	LLItemBridge(inventory, root, uuid),
 	mAssetType( asset_type ),
 	mInvType(inv_type),
@@ -4553,7 +4553,7 @@ void remove_inventory_category_from_avatar_step2( BOOL proceed, LLUUID category_
 				if (item->getType() == LLAssetType::AT_BODYPART)
 					continue;
 				if (gAgent.isTeen() && item->isWearableType() &&
-					(item->getWearableType() == WT_UNDERPANTS || item->getWearableType() == WT_UNDERSHIRT))
+					(item->getWearableType() == LLWearableType::WT_UNDERPANTS || item->getWearableType() == LLWearableType::WT_UNDERSHIRT))
 					continue;
 				if (get_is_item_worn(item->getUUID()))
 				{
@@ -4975,10 +4975,10 @@ void LLWearableBridge::onRemoveFromAvatarArrived(LLWearable* wearable,
 	{
 		if( get_is_item_worn( item_id ) )
 		{
-			EWearableType type = wearable->getType();
+			LLWearableType::EType type = wearable->getType();
 
-			if( !(type==WT_SHAPE || type==WT_SKIN || type==WT_HAIR || type==WT_EYES ) ) //&&
-				//!((!gAgent.isTeen()) && ( type==WT_UNDERPANTS || type==WT_UNDERSHIRT )) )
+			if( !(type==LLWearableType::WT_SHAPE || type==LLWearableType::WT_SKIN || type==LLWearableType::WT_HAIR || type==LLWearableType::WT_EYES ) ) //&&
+				//!((!gAgent.isTeen()) && ( type==LLWearableType::WT_UNDERPANTS || type==LLWearableType::WT_UNDERSHIRT )) )
 			{
 				bool do_remove_all = false;
 				U32 index = gAgentWearables.getWearableIndex(wearable);
@@ -4998,14 +4998,14 @@ void LLWearableBridge::onRemoveFromAvatarArrived(LLWearable* wearable,
 void LLWearableBridge::removeAllClothesFromAvatar()
 {
 	// Remove COF links.
-	for (S32 itype = WT_SHAPE; itype < WT_COUNT; ++itype)
+	for (S32 itype = LLWearableType::WT_SHAPE; itype < LLWearableType::WT_COUNT; ++itype)
 	{
-		if (itype == WT_SHAPE || itype == WT_SKIN || itype == WT_HAIR || itype == WT_EYES)
+		if (itype == LLWearableType::WT_SHAPE || itype == LLWearableType::WT_SKIN || itype == LLWearableType::WT_HAIR || itype == LLWearableType::WT_EYES)
 			continue;
 
 		// MULTI-WEARABLES: fixed to index 0
 		LLViewerInventoryItem *item = dynamic_cast<LLViewerInventoryItem*>(
-			gAgentWearables.getWearableInventoryItem((EWearableType)itype, 0));
+			gAgentWearables.getWearableInventoryItem((LLWearableType::EType)itype, 0));
 		if (!item)
 			continue;
 		const LLUUID &item_id = gInventory.getLinkedItemID(item->getUUID());
diff --git a/indra/newview/llinventorybridge.h b/indra/newview/llinventorybridge.h
index d1094b66d4..d77062ba84 100644
--- a/indra/newview/llinventorybridge.h
+++ b/indra/newview/llinventorybridge.h
@@ -272,8 +272,8 @@ public:
 	virtual BOOL isClipboardPasteableAsLink() const;
 	virtual BOOL copyToClipboard() const;
 	
-	static void createWearable(LLFolderBridge* bridge, EWearableType type);
-	static void createWearable(const LLUUID &parent_folder_id, EWearableType type);
+	static void createWearable(LLFolderBridge* bridge, LLWearableType::EType type);
+	static void createWearable(const LLUUID &parent_folder_id, LLWearableType::EType type);
 
 	LLViewerInventoryCategory* getCategory() const;
 
@@ -532,11 +532,11 @@ protected:
 					 const LLUUID& uuid, 
 					 LLAssetType::EType asset_type, 
 					 LLInventoryType::EType inv_type, 
-					 EWearableType wearable_type);
+					 LLWearableType::EType wearable_type);
 protected:
 	LLAssetType::EType mAssetType;
 	LLInventoryType::EType mInvType;
-	EWearableType  mWearableType;
+	LLWearableType::EType  mWearableType;
 };
 
 class LLLinkItemBridge : public LLItemBridge
diff --git a/indra/newview/llinventoryicon.cpp b/indra/newview/llinventoryicon.cpp
index 474076b541..8a679297ae 100644
--- a/indra/newview/llinventoryicon.cpp
+++ b/indra/newview/llinventoryicon.cpp
@@ -182,6 +182,6 @@ const std::string& LLInventoryIcon::getIconName(EIconName idx, BOOL item_is_link
 
 LLInventoryIcon::EIconName LLInventoryIcon::assignWearableIcon(U32 misc_flag)
 {
-	const EWearableType wearable_type = EWearableType(LLInventoryItemFlags::II_FLAGS_WEARABLES_MASK & misc_flag);
-	return LLWearableDictionary::instance().getIconName(wearable_type);
+	const LLWearableType::EType wearable_type = LLWearableType::EType(LLInventoryItemFlags::II_FLAGS_WEARABLES_MASK & misc_flag);
+	return LLWearableType::getIconName(wearable_type);
 }
diff --git a/indra/newview/llpaneleditwearable.cpp b/indra/newview/llpaneleditwearable.cpp
index 3c112b8b5e..6f2e7c0b20 100644
--- a/indra/newview/llpaneleditwearable.cpp
+++ b/indra/newview/llpaneleditwearable.cpp
@@ -115,7 +115,7 @@ public:
 public:
 	struct WearableEntry : public LLDictionaryEntry
 	{
-		WearableEntry(EWearableType type,
+		WearableEntry(LLWearableType::EType type,
 					  const std::string &title,
 					  const std::string &desc_title,
 					  U8 num_color_swatches,  // number of 'color_swatches'
@@ -123,7 +123,7 @@ public:
 					  U8 num_subparts, ... ); // number of subparts followed by a list of ETextureIndex and ESubparts
 
 
-		const EWearableType mWearableType;
+		const LLWearableType::EType mWearableType;
 		const std::string   mTitle;
 		const std::string	mDescTitle;
 		subpart_vec_t		mSubparts;
@@ -131,12 +131,12 @@ public:
 		texture_vec_t		mTextureCtrls;
 	};
 
-	struct Wearables : public LLDictionary<EWearableType, WearableEntry>
+	struct Wearables : public LLDictionary<LLWearableType::EType, WearableEntry>
 	{
 		Wearables();
 	} mWearables;
 
-	const WearableEntry*	getWearable(EWearableType type) const { return mWearables.lookup(type); }
+	const WearableEntry*	getWearable(LLWearableType::EType type) const { return mWearables.lookup(type); }
 
 	//--------------------------------------------------------------------
 	// Subparts
@@ -212,24 +212,24 @@ LLEditWearableDictionary::~LLEditWearableDictionary()
 
 LLEditWearableDictionary::Wearables::Wearables()
 {
-	addEntry(WT_SHAPE, new WearableEntry(WT_SHAPE,"edit_shape_title","shape_desc_text",0,0,9,	SUBPART_SHAPE_HEAD,	SUBPART_SHAPE_EYES,	SUBPART_SHAPE_EARS,	SUBPART_SHAPE_NOSE,	SUBPART_SHAPE_MOUTH, SUBPART_SHAPE_CHIN, SUBPART_SHAPE_TORSO, SUBPART_SHAPE_LEGS, SUBPART_SHAPE_WHOLE));
-	addEntry(WT_SKIN, new WearableEntry(WT_SKIN,"edit_skin_title","skin_desc_text",0,3,4, TEX_HEAD_BODYPAINT, TEX_UPPER_BODYPAINT, TEX_LOWER_BODYPAINT, SUBPART_SKIN_COLOR, SUBPART_SKIN_FACEDETAIL, SUBPART_SKIN_MAKEUP, SUBPART_SKIN_BODYDETAIL));
-	addEntry(WT_HAIR, new WearableEntry(WT_HAIR,"edit_hair_title","hair_desc_text",0,1,4, TEX_HAIR, SUBPART_HAIR_COLOR,	SUBPART_HAIR_STYLE,	SUBPART_HAIR_EYEBROWS, SUBPART_HAIR_FACIAL));
-	addEntry(WT_EYES, new WearableEntry(WT_EYES,"edit_eyes_title","eyes_desc_text",0,1,1, TEX_EYES_IRIS, SUBPART_EYES));
-	addEntry(WT_SHIRT, new WearableEntry(WT_SHIRT,"edit_shirt_title","shirt_desc_text",1,1,1, TEX_UPPER_SHIRT, TEX_UPPER_SHIRT, SUBPART_SHIRT));
-	addEntry(WT_PANTS, new WearableEntry(WT_PANTS,"edit_pants_title","pants_desc_text",1,1,1, TEX_LOWER_PANTS, TEX_LOWER_PANTS, SUBPART_PANTS));
-	addEntry(WT_SHOES, new WearableEntry(WT_SHOES,"edit_shoes_title","shoes_desc_text",1,1,1, TEX_LOWER_SHOES, TEX_LOWER_SHOES, SUBPART_SHOES));
-	addEntry(WT_SOCKS, new WearableEntry(WT_SOCKS,"edit_socks_title","socks_desc_text",1,1,1, TEX_LOWER_SOCKS, TEX_LOWER_SOCKS, SUBPART_SOCKS));
-	addEntry(WT_JACKET, new WearableEntry(WT_JACKET,"edit_jacket_title","jacket_desc_text",1,2,1, TEX_UPPER_JACKET, TEX_UPPER_JACKET, TEX_LOWER_JACKET, SUBPART_JACKET));
-	addEntry(WT_GLOVES, new WearableEntry(WT_GLOVES,"edit_gloves_title","gloves_desc_text",1,1,1, TEX_UPPER_GLOVES, TEX_UPPER_GLOVES, SUBPART_GLOVES));
-	addEntry(WT_UNDERSHIRT, new WearableEntry(WT_UNDERSHIRT,"edit_undershirt_title","undershirt_desc_text",1,1,1, TEX_UPPER_UNDERSHIRT, TEX_UPPER_UNDERSHIRT, SUBPART_UNDERSHIRT));
-	addEntry(WT_UNDERPANTS, new WearableEntry(WT_UNDERPANTS,"edit_underpants_title","underpants_desc_text",1,1,1, TEX_LOWER_UNDERPANTS, TEX_LOWER_UNDERPANTS, SUBPART_UNDERPANTS));
-	addEntry(WT_SKIRT, new WearableEntry(WT_SKIRT,"edit_skirt_title","skirt_desc_text",1,1,1, TEX_SKIRT, TEX_SKIRT, SUBPART_SKIRT));
-	addEntry(WT_ALPHA, new WearableEntry(WT_ALPHA,"edit_alpha_title","alpha_desc_text",0,5,1, TEX_LOWER_ALPHA, TEX_UPPER_ALPHA, TEX_HEAD_ALPHA, TEX_EYES_ALPHA, TEX_HAIR_ALPHA, SUBPART_ALPHA));
-	addEntry(WT_TATTOO, new WearableEntry(WT_TATTOO,"edit_tattoo_title","tattoo_desc_text",0,3,1, TEX_LOWER_TATTOO, TEX_UPPER_TATTOO, TEX_HEAD_TATTOO, SUBPART_TATTOO));
+	addEntry(LLWearableType::WT_SHAPE, 		new WearableEntry(LLWearableType::WT_SHAPE,"edit_shape_title","shape_desc_text",0,0,9,	SUBPART_SHAPE_HEAD,	SUBPART_SHAPE_EYES,	SUBPART_SHAPE_EARS,	SUBPART_SHAPE_NOSE,	SUBPART_SHAPE_MOUTH, SUBPART_SHAPE_CHIN, SUBPART_SHAPE_TORSO, SUBPART_SHAPE_LEGS, SUBPART_SHAPE_WHOLE));
+	addEntry(LLWearableType::WT_SKIN, 		new WearableEntry(LLWearableType::WT_SKIN,"edit_skin_title","skin_desc_text",0,3,4, TEX_HEAD_BODYPAINT, TEX_UPPER_BODYPAINT, TEX_LOWER_BODYPAINT, SUBPART_SKIN_COLOR, SUBPART_SKIN_FACEDETAIL, SUBPART_SKIN_MAKEUP, SUBPART_SKIN_BODYDETAIL));
+	addEntry(LLWearableType::WT_HAIR, 		new WearableEntry(LLWearableType::WT_HAIR,"edit_hair_title","hair_desc_text",0,1,4, TEX_HAIR, SUBPART_HAIR_COLOR,	SUBPART_HAIR_STYLE,	SUBPART_HAIR_EYEBROWS, SUBPART_HAIR_FACIAL));
+	addEntry(LLWearableType::WT_EYES, 		new WearableEntry(LLWearableType::WT_EYES,"edit_eyes_title","eyes_desc_text",0,1,1, TEX_EYES_IRIS, SUBPART_EYES));
+	addEntry(LLWearableType::WT_SHIRT, 		new WearableEntry(LLWearableType::WT_SHIRT,"edit_shirt_title","shirt_desc_text",1,1,1, TEX_UPPER_SHIRT, TEX_UPPER_SHIRT, SUBPART_SHIRT));
+	addEntry(LLWearableType::WT_PANTS, 		new WearableEntry(LLWearableType::WT_PANTS,"edit_pants_title","pants_desc_text",1,1,1, TEX_LOWER_PANTS, TEX_LOWER_PANTS, SUBPART_PANTS));
+	addEntry(LLWearableType::WT_SHOES, 		new WearableEntry(LLWearableType::WT_SHOES,"edit_shoes_title","shoes_desc_text",1,1,1, TEX_LOWER_SHOES, TEX_LOWER_SHOES, SUBPART_SHOES));
+	addEntry(LLWearableType::WT_SOCKS, 		new WearableEntry(LLWearableType::WT_SOCKS,"edit_socks_title","socks_desc_text",1,1,1, TEX_LOWER_SOCKS, TEX_LOWER_SOCKS, SUBPART_SOCKS));
+	addEntry(LLWearableType::WT_JACKET, 	new WearableEntry(LLWearableType::WT_JACKET,"edit_jacket_title","jacket_desc_text",1,2,1, TEX_UPPER_JACKET, TEX_UPPER_JACKET, TEX_LOWER_JACKET, SUBPART_JACKET));
+	addEntry(LLWearableType::WT_GLOVES, 	new WearableEntry(LLWearableType::WT_GLOVES,"edit_gloves_title","gloves_desc_text",1,1,1, TEX_UPPER_GLOVES, TEX_UPPER_GLOVES, SUBPART_GLOVES));
+	addEntry(LLWearableType::WT_UNDERSHIRT, new WearableEntry(LLWearableType::WT_UNDERSHIRT,"edit_undershirt_title","undershirt_desc_text",1,1,1, TEX_UPPER_UNDERSHIRT, TEX_UPPER_UNDERSHIRT, SUBPART_UNDERSHIRT));
+	addEntry(LLWearableType::WT_UNDERPANTS, new WearableEntry(LLWearableType::WT_UNDERPANTS,"edit_underpants_title","underpants_desc_text",1,1,1, TEX_LOWER_UNDERPANTS, TEX_LOWER_UNDERPANTS, SUBPART_UNDERPANTS));
+	addEntry(LLWearableType::WT_SKIRT, 		new WearableEntry(LLWearableType::WT_SKIRT,"edit_skirt_title","skirt_desc_text",1,1,1, TEX_SKIRT, TEX_SKIRT, SUBPART_SKIRT));
+	addEntry(LLWearableType::WT_ALPHA, 		new WearableEntry(LLWearableType::WT_ALPHA,"edit_alpha_title","alpha_desc_text",0,5,1, TEX_LOWER_ALPHA, TEX_UPPER_ALPHA, TEX_HEAD_ALPHA, TEX_EYES_ALPHA, TEX_HAIR_ALPHA, SUBPART_ALPHA));
+	addEntry(LLWearableType::WT_TATTOO, 	new WearableEntry(LLWearableType::WT_TATTOO,"edit_tattoo_title","tattoo_desc_text",0,3,1, TEX_LOWER_TATTOO, TEX_UPPER_TATTOO, TEX_HEAD_TATTOO, SUBPART_TATTOO));
 }
 
-LLEditWearableDictionary::WearableEntry::WearableEntry(EWearableType type,
+LLEditWearableDictionary::WearableEntry::WearableEntry(LLWearableType::EType type,
 					  const std::string &title,
 					  const std::string &desc_title,
 					  U8 num_color_swatches,
@@ -442,7 +442,7 @@ get_picker_entry<LLTextureCtrl> (const ETextureIndex index)
 
 template <typename CtrlType, class Predicate>
 const LLEditWearableDictionary::PickerControlEntry*
-find_picker_ctrl_entry_if(EWearableType type, const Predicate pred)
+find_picker_ctrl_entry_if(LLWearableType::EType type, const Predicate pred)
 {
 	const LLEditWearableDictionary::WearableEntry *wearable_entry
 		= LLEditWearableDictionary::getInstance()->getWearable(type);
@@ -475,7 +475,7 @@ find_picker_ctrl_entry_if(EWearableType type, const Predicate pred)
 
 template <typename CtrlType>
 void
-for_each_picker_ctrl_entry(LLPanel* panel, EWearableType type, function_t fun)
+for_each_picker_ctrl_entry(LLPanel* panel, LLWearableType::EType type, function_t fun)
 {
 	if (!panel)
 	{
@@ -694,7 +694,7 @@ void LLPanelEditWearable::onTexturePickerCommit(const LLUICtrl* ctrl)
 
 	if (getWearable())
 	{
-		EWearableType type = getWearable()->getType();
+		LLWearableType::EType type = getWearable()->getType();
 		const PickerControlEntryNamePredicate name_pred(texture_ctrl->getName());
 		const LLEditWearableDictionary::PickerControlEntry* entry
 			= find_picker_ctrl_entry_if<LLTextureCtrl, PickerControlEntryNamePredicate>(type, name_pred);
@@ -725,7 +725,7 @@ void LLPanelEditWearable::onColorSwatchCommit(const LLUICtrl* ctrl)
 {
 	if (getWearable())
 	{
-		EWearableType type = getWearable()->getType();
+		LLWearableType::EType type = getWearable()->getType();
 		const PickerControlEntryNamePredicate name_pred(ctrl->getName());
 		const LLEditWearableDictionary::PickerControlEntry* entry
 			= find_picker_ctrl_entry_if<LLColorSwatchCtrl, PickerControlEntryNamePredicate>(type, name_pred);
@@ -747,7 +747,7 @@ void LLPanelEditWearable::onColorSwatchCommit(const LLUICtrl* ctrl)
 	}
 }
 
-void LLPanelEditWearable::updatePanelPickerControls(EWearableType type)
+void LLPanelEditWearable::updatePanelPickerControls(LLWearableType::EType type)
 {
 	LLPanel* panel = getPanel(type);
 	if (!panel)
@@ -823,7 +823,7 @@ void LLPanelEditWearable::showWearable(LLWearable* wearable, BOOL show)
 	mWearableItem = gInventory.getItem(mWearablePtr->getItemID());
 	llassert(mWearableItem);
 
-	EWearableType type = wearable->getType();
+	LLWearableType::EType type = wearable->getType();
 	LLPanel *targetPanel = NULL;
 	std::string title;
 	std::string description_title;
@@ -859,7 +859,7 @@ void LLPanelEditWearable::initializePanel()
 		return;
 	}
 
-	EWearableType type = mWearablePtr->getType();
+	LLWearableType::EType type = mWearablePtr->getType();
 
 	// set name
 	mTextEditor->setText(mWearablePtr->getName());
@@ -930,7 +930,7 @@ void LLPanelEditWearable::updateScrollingPanelUI()
 		return;
 	}
 
-	EWearableType type = mWearablePtr->getType();
+	LLWearableType::EType type = mWearablePtr->getType();
 	LLPanel *panel = getPanel(type);
 
 	if(panel && (mWearablePtr->getItemID().notNull()))
@@ -960,67 +960,67 @@ void LLPanelEditWearable::updateScrollingPanelUI()
 	}
 }
 
-LLPanel* LLPanelEditWearable::getPanel(EWearableType type)
+LLPanel* LLPanelEditWearable::getPanel(LLWearableType::EType type)
 {
 	switch (type)
 	{
-		case WT_SHAPE:
+		case LLWearableType::WT_SHAPE:
 			return mPanelShape;
 			break;
 
-		case WT_SKIN:
+		case LLWearableType::WT_SKIN:
 			return mPanelSkin;
 			break;
 
-		case WT_HAIR:
+		case LLWearableType::WT_HAIR:
 			return mPanelHair;
 			break;
 
-		case WT_EYES:
+		case LLWearableType::WT_EYES:
 			return mPanelEyes;
 			break;
 
-		case WT_SHIRT:
+		case LLWearableType::WT_SHIRT:
 			return mPanelShirt;
 			break;
 
-		case WT_PANTS:
+		case LLWearableType::WT_PANTS:
 			return mPanelPants;
 			break;
 
-		case WT_SHOES:
+		case LLWearableType::WT_SHOES:
 			return mPanelShoes;
 			break;
 
-		case WT_SOCKS:
+		case LLWearableType::WT_SOCKS:
 			return mPanelSocks;
 			break;
 
-		case WT_JACKET:
+		case LLWearableType::WT_JACKET:
 			return mPanelJacket;
 			break;
 
-		case WT_GLOVES:
+		case LLWearableType::WT_GLOVES:
 			return mPanelGloves;
 			break;
 
-		case WT_UNDERSHIRT:
+		case LLWearableType::WT_UNDERSHIRT:
 			return mPanelUndershirt;
 			break;
 
-		case WT_UNDERPANTS:
+		case LLWearableType::WT_UNDERPANTS:
 			return mPanelUnderpants;
 			break;
 
-		case WT_SKIRT:
+		case LLWearableType::WT_SKIRT:
 			return mPanelSkirt;
 			break;
 
-		case WT_ALPHA:
+		case LLWearableType::WT_ALPHA:
 			return mPanelAlpha;
 			break;
 
-		case WT_TATTOO:
+		case LLWearableType::WT_TATTOO:
 			return mPanelTattoo;
 			break;
 		default:
diff --git a/indra/newview/llpaneleditwearable.h b/indra/newview/llpaneleditwearable.h
index 76b0ddb3cc..1fed77cf91 100644
--- a/indra/newview/llpaneleditwearable.h
+++ b/indra/newview/llpaneleditwearable.h
@@ -71,7 +71,7 @@ private:
 	void				showWearable(LLWearable* wearable, BOOL show);
 	void				initializePanel();
 	void				updateScrollingPanelUI();
-	LLPanel*			getPanel(EWearableType type);
+	LLPanel*			getPanel(LLWearableType::EType type);
 	void				getSortedParams(value_map_t &sorted_params, const std::string &edit_group);
 	void				buildParamList(LLScrollingPanelList *panel_list, value_map_t &sorted_params, LLAccordionCtrlTab *tab);
 	// update bottom bar buttons ("Save", "Revert", etc)
@@ -79,7 +79,7 @@ private:
 
 	void				onColorSwatchCommit(const LLUICtrl*);
 	void				onTexturePickerCommit(const LLUICtrl*);
-	void				updatePanelPickerControls(EWearableType type);
+	void				updatePanelPickerControls(LLWearableType::EType type);
 
 	// the pointer to the wearable we're editing. NULL means we're not editing a wearable.
 	LLWearable *mWearablePtr;
diff --git a/indra/newview/llsidepanelappearance.cpp b/indra/newview/llsidepanelappearance.cpp
index 18f12955ce..0086c6aec4 100644
--- a/indra/newview/llsidepanelappearance.cpp
+++ b/indra/newview/llsidepanelappearance.cpp
@@ -317,7 +317,7 @@ void LLSidepanelAppearance::toggleWearableEditPanel(BOOL visible, LLWearable *we
 {
 	if (!wearable)
 	{
-		wearable = gAgentWearables.getWearable(WT_SHAPE, 0);
+		wearable = gAgentWearables.getWearable(LLWearableType::WT_SHAPE, 0);
 	}
 	if (!mEditWearable || !wearable)
 	{
@@ -389,11 +389,11 @@ void LLSidepanelAppearance::fetchInventory()
 	mNewOutfitBtn->setEnabled(false);
 	uuid_vec_t ids;
 	LLUUID item_id;
-	for(S32 type = (S32)WT_SHAPE; type < (S32)WT_COUNT; ++type)
+	for(S32 type = (S32)LLWearableType::WT_SHAPE; type < (S32)LLWearableType::WT_COUNT; ++type)
 	{
-		for (U32 index = 0; index < gAgentWearables.getWearableCount((EWearableType)type); ++index)
+		for (U32 index = 0; index < gAgentWearables.getWearableCount((LLWearableType::EType)type); ++index)
 		{
-			item_id = gAgentWearables.getWearableItemID((EWearableType)type, index);
+			item_id = gAgentWearables.getWearableItemID((LLWearableType::EType)type, index);
 			if(item_id.notNull())
 			{
 				ids.push_back(item_id);
diff --git a/indra/newview/lltexlayer.cpp b/indra/newview/lltexlayer.cpp
index 4262264a1d..82fa672342 100644
--- a/indra/newview/lltexlayer.cpp
+++ b/indra/newview/lltexlayer.cpp
@@ -178,7 +178,7 @@ BOOL LLTexLayerSetBuffer::needsRender()
 	BOOL needs_update = (mNeedsUpdate || upload_now) && !gAgentAvatarp->mAppearanceAnimating;
 	if (needs_update)
 	{
-		BOOL invalid_skirt = gAgentAvatarp->getBakedTE(mTexLayerSet) == LLVOAvatarDefines::TEX_SKIRT_BAKED && !gAgentAvatarp->isWearingWearableType(WT_SKIRT);
+		BOOL invalid_skirt = gAgentAvatarp->getBakedTE(mTexLayerSet) == LLVOAvatarDefines::TEX_SKIRT_BAKED && !gAgentAvatarp->isWearingWearableType(LLWearableType::WT_SKIRT);
 		if (invalid_skirt)
 		{
 			// we were trying to create a skirt texture
@@ -1848,7 +1848,7 @@ U32 LLTexLayerTemplate::updateWearableCache()
 		//this isn't a cloneable layer 
 		return 0;
 	}
-	EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType((ETextureIndex)te);
+	LLWearableType::EType wearable_type = LLVOAvatarDictionary::getTEWearableType((ETextureIndex)te);
 	U32 num_wearables = gAgentWearables.getWearableCount(wearable_type);
 	U32 added = 0;
 	for (U32 i = 0; i < num_wearables; i++)
diff --git a/indra/newview/lltexlayerparams.cpp b/indra/newview/lltexlayerparams.cpp
index 5e5d344461..3c87f2386e 100644
--- a/indra/newview/lltexlayerparams.cpp
+++ b/indra/newview/lltexlayerparams.cpp
@@ -234,8 +234,8 @@ BOOL LLTexLayerParamAlpha::getSkip() const
 		}
 	}
 
-	EWearableType type = (EWearableType)getWearableType();
-	if ((type != WT_INVALID) && !avatar->isWearingWearableType(type))
+	LLWearableType::EType type = (LLWearableType::EType)getWearableType();
+	if ((type != LLWearableType::WT_NONE) && !avatar->isWearingWearableType(type))
 	{
 		return TRUE;
 	}
diff --git a/indra/newview/llviewerinventory.cpp b/indra/newview/llviewerinventory.cpp
index ed3d6a0464..ac10b09a37 100644
--- a/indra/newview/llviewerinventory.cpp
+++ b/indra/newview/llviewerinventory.cpp
@@ -724,8 +724,8 @@ void LLViewerInventoryCategory::determineFolderType()
 				return;
 			if (item->isWearableType())
 			{
-				const EWearableType wearable_type = item->getWearableType();
-				const std::string& wearable_name = LLWearableDictionary::getTypeName(wearable_type);
+				const LLWearableType::EType wearable_type = item->getWearableType();
+				const std::string& wearable_name = LLWearableType::getTypeName(wearable_type);
 				U64 valid_folder_types = LLViewerFolderType::lookupValidFolderTypes(wearable_name);
 				folder_valid |= valid_folder_types;
 				folder_invalid |= ~valid_folder_types;
@@ -909,7 +909,7 @@ void create_inventory_item(const LLUUID& agent_id, const LLUUID& session_id,
 						   const LLUUID& parent, const LLTransactionID& transaction_id,
 						   const std::string& name,
 						   const std::string& desc, LLAssetType::EType asset_type,
-						   LLInventoryType::EType inv_type, EWearableType wtype,
+						   LLInventoryType::EType inv_type, LLWearableType::EType wtype,
 						   U32 next_owner_perm,
 						   LLPointer<LLInventoryCallback> cb)
 {
@@ -1196,10 +1196,10 @@ void menu_create_inventory_item(LLFolderView* root, LLFolderBridge *bridge, cons
 	else
 	{
 		// Use for all clothing and body parts.  Adding new wearable types requires updating LLWearableDictionary.
-		EWearableType wearable_type = LLWearableDictionary::typeNameToType(type_name);
-		if (wearable_type >= WT_SHAPE && wearable_type < WT_COUNT)
+		LLWearableType::EType wearable_type = LLWearableType::typeNameToType(type_name);
+		if (wearable_type >= LLWearableType::WT_SHAPE && wearable_type < LLWearableType::WT_COUNT)
 		{
-			LLAssetType::EType asset_type = LLWearableDictionary::getAssetType(wearable_type);
+			LLAssetType::EType asset_type = LLWearableType::getAssetType(wearable_type);
 			LLFolderType::EType folder_type = LLFolderType::assetTypeToFolderType(asset_type);
 			const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(folder_type);
 			LLFolderBridge::createWearable(parent_id, wearable_type);
@@ -1537,14 +1537,14 @@ bool LLViewerInventoryItem::isWearableType() const
 	return (getInventoryType() == LLInventoryType::IT_WEARABLE);
 }
 
-EWearableType LLViewerInventoryItem::getWearableType() const
+LLWearableType::EType LLViewerInventoryItem::getWearableType() const
 {
 	if (!isWearableType())
 	{
 		llwarns << "item is not a wearable" << llendl;
-		return WT_INVALID;
+		return LLWearableType::WT_NONE;
 	}
-	return EWearableType(getFlags() & LLInventoryItemFlags::II_FLAGS_WEARABLES_MASK);
+	return LLWearableType::EType(getFlags() & LLInventoryItemFlags::II_FLAGS_WEARABLES_MASK);
 }
 
 
diff --git a/indra/newview/llviewerinventory.h b/indra/newview/llviewerinventory.h
index f296ce35ff..f0dc7bcb67 100644
--- a/indra/newview/llviewerinventory.h
+++ b/indra/newview/llviewerinventory.h
@@ -74,7 +74,7 @@ public:
 	virtual const LLSaleInfo& getSaleInfo() const;
 	virtual LLInventoryType::EType getInventoryType() const;
 	virtual bool isWearableType() const;
-	virtual EWearableType getWearableType() const;
+	virtual LLWearableType::EType getWearableType() const;
 	virtual U32 getFlags() const;
 	virtual time_t getCreationDate() const;
 	virtual U32 getCRC32() const; // really more of a checksum.
@@ -310,14 +310,14 @@ public:
 extern LLInventoryCallbackManager gInventoryCallbacks;
 
 
-#define NOT_WEARABLE (EWearableType)0
+#define NOT_WEARABLE (LLWearableType::EType)0
 
 // *TODO: Find a home for these
 void create_inventory_item(const LLUUID& agent_id, const LLUUID& session_id,
 						   const LLUUID& parent, const LLTransactionID& transaction_id,
 						   const std::string& name,
 						   const std::string& desc, LLAssetType::EType asset_type,
-						   LLInventoryType::EType inv_type, EWearableType wtype,
+						   LLInventoryType::EType inv_type, LLWearableType::EType wtype,
 						   U32 next_owner_perm,
 						   LLPointer<LLInventoryCallback> cb);
 
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 7464423f55..7690e66bff 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -7474,8 +7474,8 @@ class LLEditEnableTakeOff : public view_listener_t
 	bool handleEvent(const LLSD& userdata)
 	{
 		std::string clothing = userdata.asString();
-		EWearableType type = LLWearableDictionary::typeNameToType(clothing);
-		if (type >= WT_SHAPE && type < WT_COUNT)
+		LLWearableType::EType type = LLWearableType::typeNameToType(clothing);
+		if (type >= LLWearableType::WT_SHAPE && type < LLWearableType::WT_COUNT)
 			return LLAgentWearables::selfHasWearable(type);
 		return false;
 	}
@@ -7490,8 +7490,8 @@ class LLEditTakeOff : public view_listener_t
 			LLWearableBridge::removeAllClothesFromAvatar();
 		else
 		{
-			EWearableType type = LLWearableDictionary::typeNameToType(clothing);
-			if (type >= WT_SHAPE && type < WT_COUNT)
+			LLWearableType::EType type = LLWearableType::typeNameToType(clothing);
+			if (type >= LLWearableType::WT_SHAPE && type < LLWearableType::WT_COUNT)
 			{
 				// MULTI-WEARABLES
 				LLViewerInventoryItem *item = dynamic_cast<LLViewerInventoryItem*>(gAgentWearables.getWearableInventoryItem(type,0));
diff --git a/indra/newview/llviewervisualparam.cpp b/indra/newview/llviewervisualparam.cpp
index fad398e00b..61cf3b9b7a 100644
--- a/indra/newview/llviewervisualparam.cpp
+++ b/indra/newview/llviewervisualparam.cpp
@@ -45,7 +45,7 @@
 //-----------------------------------------------------------------------------
 LLViewerVisualParamInfo::LLViewerVisualParamInfo()
 	:
-	mWearableType( WT_INVALID ),
+	mWearableType( LLWearableType::WT_NONE ),
 	mCrossWearable(FALSE),
 	mCamDist( 0.5f ),
 	mCamAngle( 0.f ),
@@ -77,7 +77,7 @@ BOOL LLViewerVisualParamInfo::parseXml(LLXmlTreeNode *node)
 	static LLStdStringHandle wearable_string = LLXmlTree::addAttributeString("wearable");
 	if( node->getFastAttributeString( wearable_string, wearable) )
 	{
-		mWearableType = LLWearableDictionary::typeNameToType( wearable );
+		mWearableType = LLWearableType::typeNameToType( wearable );
 	}
 
 	static LLStdStringHandle edit_group_string = LLXmlTree::addAttributeString("edit_group");
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 134af871ce..441a546b64 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -826,7 +826,7 @@ BOOL LLVOAvatar::isFullyBaked()
 	for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
 	{
 		if (!isTextureDefined(mBakedTextureDatas[i].mTextureIndex)
-			&& ( (i != BAKED_SKIRT) || isWearingWearableType(WT_SKIRT) ) )
+			&& ( (i != BAKED_SKIRT) || isWearingWearableType(LLWearableType::WT_SKIRT) ) )
 		{
 			return FALSE;
 		}
@@ -3668,7 +3668,7 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
 			mMeshLOD[MESH_ID_LOWER_BODY]->updateJointGeometry();
 			mMeshLOD[MESH_ID_UPPER_BODY]->updateJointGeometry();
 
-			if( isWearingWearableType( WT_SKIRT ) )
+			if( isWearingWearableType( LLWearableType::WT_SKIRT ) )
 			{
 				mMeshLOD[MESH_ID_SKIRT]->updateJointGeometry();
 			}
@@ -3828,7 +3828,7 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
 U32 LLVOAvatar::renderTransparent(BOOL first_pass)
 {
 	U32 num_indices = 0;
-	if( isWearingWearableType( WT_SKIRT ) && (mIsDummy || isTextureVisible(TEX_SKIRT_BAKED)) )
+	if( isWearingWearableType( LLWearableType::WT_SKIRT ) && (mIsDummy || isTextureVisible(TEX_SKIRT_BAKED)) )
 	{
 		gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.25f);
 		num_indices += mMeshLOD[MESH_ID_SKIRT]->render(mAdjustedPixelArea, FALSE);
@@ -4031,7 +4031,7 @@ void LLVOAvatar::updateTextures()
 	mHasGrey = FALSE; // debug
 	for (U32 texture_index = 0; texture_index < getNumTEs(); texture_index++)
 	{
-		EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType((ETextureIndex)texture_index);
+		LLWearableType::EType wearable_type = LLVOAvatarDictionary::getTEWearableType((ETextureIndex)texture_index);
 		U32 num_wearables = gAgentWearables.getWearableCount(wearable_type);
 		const LLTextureEntry *te = getTE(texture_index);
 		const F32 texel_area_ratio = fabs(te->mScaleS * te->mScaleT);
@@ -6207,7 +6207,7 @@ void LLVOAvatar::releaseComponentTextures()
 		const LLVOAvatarDictionary::BakedEntry * bakedDicEntry = LLVOAvatarDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)baked_index);
 		// skip if this is a skirt and av is not wearing one, or if we don't have a baked texture UUID
 		if (!isTextureDefined(bakedDicEntry->mTextureIndex)
-			&& ( (baked_index != BAKED_SKIRT) || isWearingWearableType(WT_SKIRT) ))
+			&& ( (baked_index != BAKED_SKIRT) || isWearingWearableType(LLWearableType::WT_SKIRT) ))
 		{
 			continue;
 		}
@@ -6355,23 +6355,23 @@ void LLVOAvatar::dumpAvatarTEs( const std::string& context ) const
 }
 
 // Unlike most wearable functions, this works for both self and other.
-BOOL LLVOAvatar::isWearingWearableType(EWearableType type) const
+BOOL LLVOAvatar::isWearingWearableType(LLWearableType::EType type) const
 {
 	if (mIsDummy) return TRUE;
 
 	switch(type)
 	{
-		case WT_SHAPE:
-		case WT_SKIN:
-		case WT_HAIR:
-		case WT_EYES:
+		case LLWearableType::WT_SHAPE:
+		case LLWearableType::WT_SKIN:
+		case LLWearableType::WT_HAIR:
+		case LLWearableType::WT_EYES:
 			return TRUE;  // everyone has all bodyparts
 		default:
 			break; // Do nothing
 	}
 
 	/* switch(type)
-		case WT_SHIRT:
+		case LLWearableType::WT_SHIRT:
 			indicator_te = TEX_UPPER_SHIRT; */
 	for (LLVOAvatarDictionary::Textures::const_iterator tex_iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
 		 tex_iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
@@ -6888,9 +6888,9 @@ void LLVOAvatar::dumpArchetypeXML( void* )
 	apr_file_printf( file, "\n\t<archetype name=\"???\">\n" );
 
 	// only body parts, not clothing.
-	for (S32 type = WT_SHAPE; type <= WT_EYES; type++)
+	for (S32 type = LLWearableType::WT_SHAPE; type <= LLWearableType::WT_EYES; type++)
 	{
-		const std::string& wearable_name = LLWearableDictionary::getTypeName((EWearableType)type);
+		const std::string& wearable_name = LLWearableType::getTypeName((LLWearableType::EType)type);
 		apr_file_printf( file, "\n\t\t<!-- wearable: %s -->\n", wearable_name.c_str() );
 
 		for (LLVisualParam* param = gAgentAvatarp->getFirstVisualParam(); param; param = gAgentAvatarp->getNextVisualParam())
@@ -7696,7 +7696,7 @@ void LLVOAvatar::idleUpdateRenderCost()
 	{
 		const LLVOAvatarDictionary::BakedEntry *baked_dict = LLVOAvatarDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)baked_index);
 		ETextureIndex tex_index = baked_dict->mTextureIndex;
-		if ((tex_index != TEX_SKIRT_BAKED) || (isWearingWearableType(WT_SKIRT)))
+		if ((tex_index != TEX_SKIRT_BAKED) || (isWearingWearableType(LLWearableType::WT_SKIRT)))
 		{
 			if (isTextureVisible(tex_index))
 			{
diff --git a/indra/newview/llvoavatar.h b/indra/newview/llvoavatar.h
index c80d59966c..9533d820eb 100644
--- a/indra/newview/llvoavatar.h
+++ b/indra/newview/llvoavatar.h
@@ -646,7 +646,7 @@ public:
  **/
 
 public:
-	virtual BOOL			isWearingWearableType(EWearableType type ) const;
+	virtual BOOL			isWearingWearableType(LLWearableType::EType type ) const;
 	
 	//--------------------------------------------------------------------
 	// Attachments
diff --git a/indra/newview/llvoavatardefines.cpp b/indra/newview/llvoavatardefines.cpp
index 49c4a1a6c8..ed0a4f147d 100644
--- a/indra/newview/llvoavatardefines.cpp
+++ b/indra/newview/llvoavatardefines.cpp
@@ -46,31 +46,31 @@ using namespace LLVOAvatarDefines;
 
 LLVOAvatarDictionary::Textures::Textures()
 {
-	addEntry(TEX_HEAD_BODYPAINT,              new TextureEntry("head_bodypaint",   TRUE,  BAKED_NUM_INDICES, "",                          WT_SKIN));
-	addEntry(TEX_UPPER_SHIRT,                 new TextureEntry("upper_shirt",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultShirtUUID",     WT_SHIRT));
-	addEntry(TEX_LOWER_PANTS,                 new TextureEntry("lower_pants",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultPantsUUID",     WT_PANTS));
-	addEntry(TEX_EYES_IRIS,                   new TextureEntry("eyes_iris",        TRUE,  BAKED_NUM_INDICES, "UIImgDefaultEyesUUID",      WT_EYES));
-	addEntry(TEX_HAIR,                        new TextureEntry("hair_grain",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultHairUUID",      WT_HAIR));
-	addEntry(TEX_UPPER_BODYPAINT,             new TextureEntry("upper_bodypaint",  TRUE,  BAKED_NUM_INDICES, "",                          WT_SKIN));
-	addEntry(TEX_LOWER_BODYPAINT,             new TextureEntry("lower_bodypaint",  TRUE,  BAKED_NUM_INDICES, "",                          WT_SKIN));
-	addEntry(TEX_LOWER_SHOES,                 new TextureEntry("lower_shoes",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultShoesUUID",     WT_SHOES));
-	addEntry(TEX_LOWER_SOCKS,                 new TextureEntry("lower_socks",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultSocksUUID",     WT_SOCKS));
-	addEntry(TEX_UPPER_JACKET,                new TextureEntry("upper_jacket",     TRUE,  BAKED_NUM_INDICES, "UIImgDefaultJacketUUID",    WT_JACKET));
-	addEntry(TEX_LOWER_JACKET,                new TextureEntry("lower_jacket",     TRUE,  BAKED_NUM_INDICES, "UIImgDefaultJacketUUID",    WT_JACKET));
-	addEntry(TEX_UPPER_GLOVES,                new TextureEntry("upper_gloves",     TRUE,  BAKED_NUM_INDICES, "UIImgDefaultGlovesUUID",    WT_GLOVES));
-	addEntry(TEX_UPPER_UNDERSHIRT,            new TextureEntry("upper_undershirt", TRUE,  BAKED_NUM_INDICES, "UIImgDefaultUnderwearUUID", WT_UNDERSHIRT));
-	addEntry(TEX_LOWER_UNDERPANTS,            new TextureEntry("lower_underpants", TRUE,  BAKED_NUM_INDICES, "UIImgDefaultUnderwearUUID", WT_UNDERPANTS));
-	addEntry(TEX_SKIRT,                       new TextureEntry("skirt",            TRUE,  BAKED_NUM_INDICES, "UIImgDefaultSkirtUUID",     WT_SKIRT));
+	addEntry(TEX_HEAD_BODYPAINT,              new TextureEntry("head_bodypaint",   TRUE,  BAKED_NUM_INDICES, "",                          LLWearableType::WT_SKIN));
+	addEntry(TEX_UPPER_SHIRT,                 new TextureEntry("upper_shirt",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultShirtUUID",     LLWearableType::WT_SHIRT));
+	addEntry(TEX_LOWER_PANTS,                 new TextureEntry("lower_pants",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultPantsUUID",     LLWearableType::WT_PANTS));
+	addEntry(TEX_EYES_IRIS,                   new TextureEntry("eyes_iris",        TRUE,  BAKED_NUM_INDICES, "UIImgDefaultEyesUUID",      LLWearableType::WT_EYES));
+	addEntry(TEX_HAIR,                        new TextureEntry("hair_grain",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultHairUUID",      LLWearableType::WT_HAIR));
+	addEntry(TEX_UPPER_BODYPAINT,             new TextureEntry("upper_bodypaint",  TRUE,  BAKED_NUM_INDICES, "",                          LLWearableType::WT_SKIN));
+	addEntry(TEX_LOWER_BODYPAINT,             new TextureEntry("lower_bodypaint",  TRUE,  BAKED_NUM_INDICES, "",                          LLWearableType::WT_SKIN));
+	addEntry(TEX_LOWER_SHOES,                 new TextureEntry("lower_shoes",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultShoesUUID",     LLWearableType::WT_SHOES));
+	addEntry(TEX_LOWER_SOCKS,                 new TextureEntry("lower_socks",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultSocksUUID",     LLWearableType::WT_SOCKS));
+	addEntry(TEX_UPPER_JACKET,                new TextureEntry("upper_jacket",     TRUE,  BAKED_NUM_INDICES, "UIImgDefaultJacketUUID",    LLWearableType::WT_JACKET));
+	addEntry(TEX_LOWER_JACKET,                new TextureEntry("lower_jacket",     TRUE,  BAKED_NUM_INDICES, "UIImgDefaultJacketUUID",    LLWearableType::WT_JACKET));
+	addEntry(TEX_UPPER_GLOVES,                new TextureEntry("upper_gloves",     TRUE,  BAKED_NUM_INDICES, "UIImgDefaultGlovesUUID",    LLWearableType::WT_GLOVES));
+	addEntry(TEX_UPPER_UNDERSHIRT,            new TextureEntry("upper_undershirt", TRUE,  BAKED_NUM_INDICES, "UIImgDefaultUnderwearUUID", LLWearableType::WT_UNDERSHIRT));
+	addEntry(TEX_LOWER_UNDERPANTS,            new TextureEntry("lower_underpants", TRUE,  BAKED_NUM_INDICES, "UIImgDefaultUnderwearUUID", LLWearableType::WT_UNDERPANTS));
+	addEntry(TEX_SKIRT,                       new TextureEntry("skirt",            TRUE,  BAKED_NUM_INDICES, "UIImgDefaultSkirtUUID",     LLWearableType::WT_SKIRT));
 
-	addEntry(TEX_LOWER_ALPHA,                 new TextureEntry("lower_alpha",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     WT_ALPHA));
-	addEntry(TEX_UPPER_ALPHA,                 new TextureEntry("upper_alpha",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     WT_ALPHA));
-	addEntry(TEX_HEAD_ALPHA,                  new TextureEntry("head_alpha",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     WT_ALPHA));
-	addEntry(TEX_EYES_ALPHA,                  new TextureEntry("eyes_alpha",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     WT_ALPHA));
-	addEntry(TEX_HAIR_ALPHA,                  new TextureEntry("hair_alpha",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     WT_ALPHA));
+	addEntry(TEX_LOWER_ALPHA,                 new TextureEntry("lower_alpha",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     LLWearableType::WT_ALPHA));
+	addEntry(TEX_UPPER_ALPHA,                 new TextureEntry("upper_alpha",      TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     LLWearableType::WT_ALPHA));
+	addEntry(TEX_HEAD_ALPHA,                  new TextureEntry("head_alpha",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     LLWearableType::WT_ALPHA));
+	addEntry(TEX_EYES_ALPHA,                  new TextureEntry("eyes_alpha",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     LLWearableType::WT_ALPHA));
+	addEntry(TEX_HAIR_ALPHA,                  new TextureEntry("hair_alpha",       TRUE,  BAKED_NUM_INDICES, "UIImgDefaultAlphaUUID",     LLWearableType::WT_ALPHA));
 
-	addEntry(TEX_HEAD_TATTOO,                 new TextureEntry("head_tattoo",      TRUE,  BAKED_NUM_INDICES, "",     WT_TATTOO));
-	addEntry(TEX_UPPER_TATTOO,                new TextureEntry("upper_tattoo",     TRUE,  BAKED_NUM_INDICES, "",     WT_TATTOO));
-	addEntry(TEX_LOWER_TATTOO,                new TextureEntry("lower_tattoo",     TRUE,  BAKED_NUM_INDICES, "",     WT_TATTOO));
+	addEntry(TEX_HEAD_TATTOO,                 new TextureEntry("head_tattoo",      TRUE,  BAKED_NUM_INDICES, "",     LLWearableType::WT_TATTOO));
+	addEntry(TEX_UPPER_TATTOO,                new TextureEntry("upper_tattoo",     TRUE,  BAKED_NUM_INDICES, "",     LLWearableType::WT_TATTOO));
+	addEntry(TEX_LOWER_TATTOO,                new TextureEntry("lower_tattoo",     TRUE,  BAKED_NUM_INDICES, "",     LLWearableType::WT_TATTOO));
 
 	addEntry(TEX_HEAD_BAKED,                  new TextureEntry("head-baked",       FALSE, BAKED_HEAD));
 	addEntry(TEX_UPPER_BAKED,                 new TextureEntry("upper-baked",      FALSE, BAKED_UPPER));
@@ -86,34 +86,34 @@ LLVOAvatarDictionary::BakedTextures::BakedTextures()
 	addEntry(BAKED_HEAD,       new BakedEntry(TEX_HEAD_BAKED,  
 											  "head", "a4b9dc38-e13b-4df9-b284-751efb0566ff", 
 											  3, TEX_HEAD_BODYPAINT, TEX_HEAD_TATTOO, TEX_HEAD_ALPHA,
-											  5, WT_SHAPE, WT_SKIN, WT_HAIR, WT_TATTOO, WT_ALPHA));
+											  5, LLWearableType::WT_SHAPE, LLWearableType::WT_SKIN, LLWearableType::WT_HAIR, LLWearableType::WT_TATTOO, LLWearableType::WT_ALPHA));
 
 	addEntry(BAKED_UPPER,      new BakedEntry(TEX_UPPER_BAKED, 
 											  "upper_body", "5943ff64-d26c-4a90-a8c0-d61f56bd98d4", 
 											  7, TEX_UPPER_SHIRT,TEX_UPPER_BODYPAINT, TEX_UPPER_JACKET,
 											  TEX_UPPER_GLOVES, TEX_UPPER_UNDERSHIRT, TEX_UPPER_TATTOO, TEX_UPPER_ALPHA,
-											  8, WT_SHAPE, WT_SKIN,	WT_SHIRT, WT_JACKET, WT_GLOVES, WT_UNDERSHIRT, WT_TATTOO, WT_ALPHA));											  
+											  8, LLWearableType::WT_SHAPE, LLWearableType::WT_SKIN,	LLWearableType::WT_SHIRT, LLWearableType::WT_JACKET, LLWearableType::WT_GLOVES, LLWearableType::WT_UNDERSHIRT, LLWearableType::WT_TATTOO, LLWearableType::WT_ALPHA));											  
 
 	addEntry(BAKED_LOWER,      new BakedEntry(TEX_LOWER_BAKED, 
 											  "lower_body", "2944ee70-90a7-425d-a5fb-d749c782ed7d",
 											  8, TEX_LOWER_PANTS,TEX_LOWER_BODYPAINT,TEX_LOWER_SHOES, TEX_LOWER_SOCKS,
 											  TEX_LOWER_JACKET, TEX_LOWER_UNDERPANTS, TEX_LOWER_TATTOO, TEX_LOWER_ALPHA,
-											  9, WT_SHAPE, WT_SKIN,	WT_PANTS, WT_SHOES,	 WT_SOCKS,  WT_JACKET, WT_UNDERPANTS, WT_TATTOO, WT_ALPHA));
+											  9, LLWearableType::WT_SHAPE, LLWearableType::WT_SKIN,	LLWearableType::WT_PANTS, LLWearableType::WT_SHOES,	 LLWearableType::WT_SOCKS,  LLWearableType::WT_JACKET, LLWearableType::WT_UNDERPANTS, LLWearableType::WT_TATTOO, LLWearableType::WT_ALPHA));
 
 	addEntry(BAKED_EYES,       new BakedEntry(TEX_EYES_BAKED,  
 											  "eyes", "27b1bc0f-979f-4b13-95fe-b981c2ba9788",
 											  2, TEX_EYES_IRIS, TEX_EYES_ALPHA,
-											  2, WT_EYES, WT_ALPHA));
+											  2, LLWearableType::WT_EYES, LLWearableType::WT_ALPHA));
 
 	addEntry(BAKED_SKIRT,      new BakedEntry(TEX_SKIRT_BAKED,
 											  "skirt", "03e7e8cb-1368-483b-b6f3-74850838ba63", 
 											  1, TEX_SKIRT,
-											  1, WT_SKIRT));
+											  1, LLWearableType::WT_SKIRT));
 
 	addEntry(BAKED_HAIR,       new BakedEntry(TEX_HAIR_BAKED,
 											  "hair", "a60e85a9-74e8-48d8-8a2d-8129f28d9b61", 
 											  2, TEX_HAIR, TEX_HAIR_ALPHA,
-											  2, WT_HAIR, WT_ALPHA));
+											  2, LLWearableType::WT_HAIR, LLWearableType::WT_ALPHA));
 }
 
 LLVOAvatarDictionary::Meshes::Meshes()
@@ -170,7 +170,7 @@ LLVOAvatarDictionary::TextureEntry::TextureEntry(const std::string &name,
 												 bool is_local_texture, 
 												 EBakedTextureIndex baked_texture_index,
 												 const std::string &default_image_name,
-												 EWearableType wearable_type) :
+												 LLWearableType::EType wearable_type) :
 	LLDictionaryEntry(name),
 	mIsLocalTexture(is_local_texture),
 	mIsBakedTexture(!is_local_texture),
@@ -216,7 +216,7 @@ LLVOAvatarDictionary::BakedEntry::BakedEntry(ETextureIndex tex_index,
 	// Read in wearables
 	for (U8 i=0; i < num_wearables; i++)
 	{
-		EWearableType t = (EWearableType)va_arg(argp,int);
+		LLWearableType::EType t = (LLWearableType::EType)va_arg(argp,int);
 		mWearables.push_back(t);
 	}
 }
@@ -261,7 +261,7 @@ const LLUUID LLVOAvatarDictionary::getDefaultTextureImageID(ETextureIndex index)
 }
 
 // static
-EWearableType LLVOAvatarDictionary::getTEWearableType(ETextureIndex index )
+LLWearableType::EType LLVOAvatarDictionary::getTEWearableType(ETextureIndex index )
 {
 	return getInstance()->getTexture(index)->mWearableType;
 }
diff --git a/indra/newview/llvoavatardefines.h b/indra/newview/llvoavatardefines.h
index cf3d318159..cdf24dfdd9 100644
--- a/indra/newview/llvoavatardefines.h
+++ b/indra/newview/llvoavatardefines.h
@@ -114,7 +114,7 @@ enum EMeshIndex
 typedef std::vector<ETextureIndex> texture_vec_t;
 typedef std::vector<EBakedTextureIndex> bakedtexture_vec_t;
 typedef std::vector<EMeshIndex> mesh_vec_t;
-typedef std::vector<EWearableType> wearables_vec_t;
+typedef std::vector<LLWearableType::EType> wearables_vec_t;
 
 //------------------------------------------------------------------------
 // LLVOAvatarDictionary
@@ -145,9 +145,9 @@ public:
 					 bool is_local_texture, 
 					 EBakedTextureIndex baked_texture_index = BAKED_NUM_INDICES,
 					 const std::string& default_image_name = "",
-					 EWearableType wearable_type = WT_INVALID);
+					 LLWearableType::EType wearable_type = LLWearableType::WT_NONE);
 		const std::string 	mDefaultImageName;
-		const EWearableType mWearableType;
+		const LLWearableType::EType mWearableType;
 		// It's either a local texture xor baked
 		BOOL 				mIsLocalTexture;
 		BOOL 				mIsBakedTexture;
@@ -225,7 +225,7 @@ public:
 	static const LLUUID			getDefaultTextureImageID(ETextureIndex index);
 
 	// Given a texture entry, determine which wearable type owns it.
-	static EWearableType 		getTEWearableType(ETextureIndex index);
+	static LLWearableType::EType 		getTEWearableType(ETextureIndex index);
 
 }; // End LLVOAvatarDictionary
 
diff --git a/indra/newview/llvoavatarself.cpp b/indra/newview/llvoavatarself.cpp
index 63f060b58a..322350d2d9 100644
--- a/indra/newview/llvoavatarself.cpp
+++ b/indra/newview/llvoavatarself.cpp
@@ -183,7 +183,7 @@ void LLVOAvatarSelf::markDead()
 		 param;
 		 param = (LLViewerVisualParam*) getNextVisualParam())
 	{
-		if (param->getWearableType() != WT_INVALID)
+		if (param->getWearableType() != LLWearableType::WT_NONE)
 		{
 			param->setIsDummy(TRUE);
 		}
@@ -679,7 +679,7 @@ BOOL LLVOAvatarSelf::setParamWeight(LLViewerVisualParam *param, F32 weight, BOOL
 
 	if (param->getCrossWearable())
 	{
-		EWearableType type = (EWearableType)param->getWearableType();
+		LLWearableType::EType type = (LLWearableType::EType)param->getWearableType();
 		U32 size = gAgentWearables.getWearableCount(type);
 		for (U32 count = 0; count < size; ++count)
 		{
@@ -707,9 +707,9 @@ void LLVOAvatarSelf::idleUpdateAppearanceAnimation()
 	gAgentWearables.animateAllWearableParams(calcMorphAmount(), FALSE);
 
 	// apply wearable visual params to avatar
-	for (U32 type = 0; type < WT_COUNT; type++)
+	for (U32 type = 0; type < LLWearableType::WT_COUNT; type++)
 	{
-		LLWearable *wearable = gAgentWearables.getTopWearable((EWearableType)type);
+		LLWearable *wearable = gAgentWearables.getTopWearable((LLWearableType::EType)type);
 		if (wearable)
 		{
 			wearable->writeToAvatar();
@@ -943,17 +943,17 @@ void LLVOAvatarSelf::updateAttachmentVisibility(U32 camera_mode)
 	}
 }
 
-/*virtual*/ BOOL LLVOAvatarSelf::isWearingWearableType(EWearableType type ) const
+/*virtual*/ BOOL LLVOAvatarSelf::isWearingWearableType(LLWearableType::EType type ) const
 {
 	return gAgentWearables.getWearableCount(type) > 0;
 }
 
 //-----------------------------------------------------------------------------
-// updatedWearable( EWearableType type )
+// updatedWearable( LLWearableType::EType type )
 // forces an update to any baked textures relevant to type.
 // will force an upload of the resulting bake if the second parameter is TRUE
 //-----------------------------------------------------------------------------
-void LLVOAvatarSelf::wearableUpdated( EWearableType type, BOOL upload_result )
+void LLVOAvatarSelf::wearableUpdated( LLWearableType::EType type, BOOL upload_result )
 {
 	for (LLVOAvatarDictionary::BakedTextures::const_iterator baked_iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
 		 baked_iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
@@ -974,7 +974,7 @@ void LLVOAvatarSelf::wearableUpdated( EWearableType type, BOOL upload_result )
 				type_iter != baked_dict->mWearables.end();
 				 ++type_iter)
 			{
-				const EWearableType comp_type = *type_iter;
+				const LLWearableType::EType comp_type = *type_iter;
 				if (comp_type == type)
 				{
 					if (mBakedTextureDatas[index].mTexLayerSet)
@@ -1110,7 +1110,7 @@ BOOL LLVOAvatarSelf::detachObject(LLViewerObject *viewer_object)
 
 U32 LLVOAvatarSelf::getNumWearables(LLVOAvatarDefines::ETextureIndex i) const
 {
-	EWearableType type = LLVOAvatarDictionary::getInstance()->getTEWearableType(i);
+	LLWearableType::EType type = LLVOAvatarDictionary::getInstance()->getTEWearableType(i);
 	return gAgentWearables.getWearableCount(type);
 }
 
@@ -1238,7 +1238,7 @@ BOOL LLVOAvatarSelf::isLocalTextureDataAvailable(const LLTexLayerSet* layerset)
 				 ++local_tex_iter)
 			{
 				const ETextureIndex tex_index = *local_tex_iter;
-				const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType(tex_index);
+				const LLWearableType::EType wearable_type = LLVOAvatarDictionary::getTEWearableType(tex_index);
 				const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
 				for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
 				{
@@ -1270,7 +1270,7 @@ BOOL LLVOAvatarSelf::isLocalTextureDataFinal(const LLTexLayerSet* layerset) cons
 				 ++local_tex_iter)
 			{
 				const ETextureIndex tex_index = *local_tex_iter;
-				const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType(tex_index);
+				const LLWearableType::EType wearable_type = LLVOAvatarDictionary::getTEWearableType(tex_index);
 				const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
 				for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
 				{
@@ -1293,7 +1293,7 @@ BOOL LLVOAvatarSelf::isTextureDefined(LLVOAvatarDefines::ETextureIndex type, U32
 	BOOL isDefined = TRUE;
 	if (isIndexLocalTexture(type))
 	{
-		const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType(type);
+		const LLWearableType::EType wearable_type = LLVOAvatarDictionary::getTEWearableType(type);
 		const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
 		if (index >= wearable_count)
 		{
@@ -1435,7 +1435,7 @@ void LLVOAvatarSelf::updateComposites()
 	for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
 	{
 		if (mBakedTextureDatas[i].mTexLayerSet 
-			&& ((i != BAKED_SKIRT) || isWearingWearableType(WT_SKIRT)))
+			&& ((i != BAKED_SKIRT) || isWearingWearableType(LLWearableType::WT_SKIRT)))
 		{
 			mBakedTextureDatas[i].mTexLayerSet->updateComposite();
 		}
@@ -1514,7 +1514,7 @@ void LLVOAvatarSelf::setLocalTexture(ETextureIndex type, LLViewerTexture* src_te
 			llerrs << "Tried to set local texture with invalid type: (" << (U32) type << ", " << index << ")" << llendl;
 			return;
 		}
-		EWearableType wearable_type = LLVOAvatarDictionary::getInstance()->getTEWearableType(type);
+		LLWearableType::EType wearable_type = LLVOAvatarDictionary::getInstance()->getTEWearableType(type);
 		if (!gAgentWearables.getWearable(wearable_type,index))
 		{
 			// no wearable is loaded, cannot set the texture.
@@ -1700,10 +1700,10 @@ void LLVOAvatarSelf::dumpTotalLocalTextureByteCount()
 BOOL LLVOAvatarSelf::getIsCloud()
 {
 	// do we have our body parts?
-	if (gAgentWearables.getWearableCount(WT_SHAPE) == 0 ||
-		gAgentWearables.getWearableCount(WT_HAIR) == 0 ||
-		gAgentWearables.getWearableCount(WT_EYES) == 0 ||
-		gAgentWearables.getWearableCount(WT_SKIN) == 0)	
+	if (gAgentWearables.getWearableCount(LLWearableType::WT_SHAPE) == 0 ||
+		gAgentWearables.getWearableCount(LLWearableType::WT_HAIR) == 0 ||
+		gAgentWearables.getWearableCount(LLWearableType::WT_EYES) == 0 ||
+		gAgentWearables.getWearableCount(LLWearableType::WT_SKIN) == 0)	
 	{
 		return TRUE;
 	}
@@ -1729,7 +1729,7 @@ BOOL LLVOAvatarSelf::getIsCloud()
 
 		for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
 		{
-			if (i == BAKED_SKIRT && !isWearingWearableType(WT_SKIRT))
+			if (i == BAKED_SKIRT && !isWearingWearableType(LLWearableType::WT_SKIRT))
 				continue;
 
 			const BakedTextureData& texture_data = mBakedTextureDatas[i];
@@ -1852,7 +1852,7 @@ void LLVOAvatarSelf::addLocalTextureStats( ETextureIndex type, LLViewerFetchedTe
 
 LLLocalTextureObject* LLVOAvatarSelf::getLocalTextureObject(LLVOAvatarDefines::ETextureIndex i, U32 wearable_index) const
 {
-	EWearableType type = LLVOAvatarDictionary::getInstance()->getTEWearableType(i);
+	LLWearableType::EType type = LLVOAvatarDictionary::getInstance()->getTEWearableType(i);
 	LLWearable* wearable = gAgentWearables.getWearable(type, wearable_index);
 	if (wearable)
 	{
diff --git a/indra/newview/llvoavatarself.h b/indra/newview/llvoavatarself.h
index 337d445eac..e5949ae941 100644
--- a/indra/newview/llvoavatarself.h
+++ b/indra/newview/llvoavatarself.h
@@ -272,8 +272,8 @@ protected:
  **/
 
 public:
-	/*virtual*/ BOOL	isWearingWearableType(EWearableType type) const;
-	void				wearableUpdated(EWearableType type, BOOL upload_result);
+	/*virtual*/ BOOL	isWearingWearableType(LLWearableType::EType type) const;
+	void				wearableUpdated(LLWearableType::EType type, BOOL upload_result);
 protected:
 	U32 getNumWearables(LLVOAvatarDefines::ETextureIndex i) const;
 
diff --git a/indra/newview/llwearable.cpp b/indra/newview/llwearable.cpp
index 63f99273fe..25ddf2c4bb 100644
--- a/indra/newview/llwearable.cpp
+++ b/indra/newview/llwearable.cpp
@@ -88,7 +88,7 @@ static std::string asset_id_to_filename(const LLUUID &asset_id);
 
 LLWearable::LLWearable(const LLTransactionID& transaction_id) :
 	mDefinitionVersion(LLWearable::sCurrentDefinitionVersion),
-	mType(WT_INVALID)
+	mType(LLWearableType::WT_NONE)
 {
 	mTransactionID = transaction_id;
 	mAssetID = mTransactionID.makeAssetID(gAgent.getSecureSessionID());
@@ -96,7 +96,7 @@ LLWearable::LLWearable(const LLTransactionID& transaction_id) :
 
 LLWearable::LLWearable(const LLAssetID& asset_id) :
 	mDefinitionVersion( LLWearable::sCurrentDefinitionVersion ),
-	mType(WT_INVALID)
+	mType(LLWearableType::WT_NONE)
 {
 	mAssetID = asset_id;
 	mTransactionID.setNull();
@@ -108,17 +108,17 @@ LLWearable::~LLWearable()
 
 const std::string& LLWearable::getTypeLabel() const
 {
-	return LLWearableDictionary::getTypeLabel(mType);
+	return LLWearableType::getTypeLabel(mType);
 }
 
 const std::string& LLWearable::getTypeName() const
 {
-	return LLWearableDictionary::getTypeName(mType);
+	return LLWearableType::getTypeName(mType);
 }
 
 LLAssetType::EType LLWearable::getAssetType() const
 {
-	return LLWearableDictionary::getAssetType(mType);
+	return LLWearableType::getAssetType(mType);
 }
 
 BOOL LLWearable::exportFile(LLFILE* file) const
@@ -363,13 +363,13 @@ BOOL LLWearable::importFile( LLFILE* file )
 		llwarns << "Bad Wearable asset: bad type" << llendl;
 		return FALSE;
 	}
-	if( 0 <= type && type < WT_COUNT )
+	if( 0 <= type && type < LLWearableType::WT_COUNT )
 	{
-		setType((EWearableType)type);
+		setType((LLWearableType::EType)type);
 	}
 	else
 	{
-		mType = WT_COUNT;
+		mType = LLWearableType::WT_COUNT;
 		llwarns << "Bad Wearable asset: bad type #" << type <<  llendl;
 		return FALSE;
 	}
@@ -679,15 +679,15 @@ void LLWearable::writeToAvatar()
 
 // Updates the user's avatar's appearance, replacing this wearables' parameters and textures with default values.
 // static 
-void LLWearable::removeFromAvatar( EWearableType type, BOOL upload_bake )
+void LLWearable::removeFromAvatar( LLWearableType::EType type, BOOL upload_bake )
 {
 	if (!isAgentAvatarValid()) return;
 
 	// You can't just remove body parts.
-	if( (type == WT_SHAPE) ||
-		(type == WT_SKIN) ||
-		(type == WT_HAIR) ||
-		(type == WT_EYES) )
+	if( (type == LLWearableType::WT_SHAPE) ||
+		(type == LLWearableType::WT_SKIN) ||
+		(type == LLWearableType::WT_HAIR) ||
+		(type == LLWearableType::WT_EYES) )
 	{
 		return;
 	}
@@ -789,7 +789,7 @@ const LLUUID& LLWearable::getItemID() const
 	return mItemID;
 }
 
-void LLWearable::setType(EWearableType type) 
+void LLWearable::setType(LLWearableType::EType type) 
 { 
 	mType = type; 
 	createVisualParams();
@@ -1118,7 +1118,7 @@ void LLWearable::refreshName()
 
 struct LLWearableSaveData
 {
-	EWearableType mType;
+	LLWearableType::EType mType;
 };
 
 void LLWearable::saveNewAsset() const
@@ -1181,7 +1181,7 @@ void LLWearable::saveNewAsset() const
 void LLWearable::onSaveNewAssetComplete(const LLUUID& new_asset_id, void* userdata, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
 {
 	LLWearableSaveData* data = (LLWearableSaveData*)userdata;
-	const std::string& type_name = LLWearableDictionary::getTypeName(data->mType);
+	const std::string& type_name = LLWearableType::getTypeName(data->mType);
 	if(0 == status)
 	{
 		// Success
@@ -1207,7 +1207,7 @@ void LLWearable::onSaveNewAssetComplete(const LLUUID& new_asset_id, void* userda
 
 std::ostream& operator<<(std::ostream &s, const LLWearable &w)
 {
-	s << "wearable " << LLWearableDictionary::getTypeName(w.mType) << "\n";
+	s << "wearable " << LLWearableType::getTypeName(w.mType) << "\n";
 	s << "    Name: " << w.mName << "\n";
 	s << "    Desc: " << w.mDescription << "\n";
 	//w.mPermissions
diff --git a/indra/newview/llwearable.h b/indra/newview/llwearable.h
index 7bd5305079..dcc70cbda7 100644
--- a/indra/newview/llwearable.h
+++ b/indra/newview/llwearable.h
@@ -68,8 +68,8 @@ public:
 	const LLUUID&				getItemID() const;
 	const LLAssetID&			getAssetID() const { return mAssetID; }
 	const LLTransactionID&		getTransactionID() const { return mTransactionID; }
-	EWearableType				getType() const	{ return mType; }
-	void						setType(EWearableType type);
+	LLWearableType::EType				getType() const	{ return mType; }
+	void						setType(LLWearableType::EType type);
 	const std::string&			getName() const	{ return mName; }
 	void						setName(const std::string& name) { mName = name; }
 	const std::string&			getDescription() const { return mDescription; }
@@ -93,7 +93,7 @@ public:
 
 	void				writeToAvatar();
 	void				removeFromAvatar( BOOL upload_bake )	{ LLWearable::removeFromAvatar( mType, upload_bake ); }
-	static void			removeFromAvatar( EWearableType type, BOOL upload_bake ); 
+	static void			removeFromAvatar( LLWearableType::EType type, BOOL upload_bake ); 
 
 	BOOL				exportFile(LLFILE* file) const;
 	BOOL				importFile(LLFILE* file);
@@ -156,7 +156,7 @@ private:
 	LLSaleInfo			mSaleInfo;
 	LLAssetID mAssetID;
 	LLTransactionID		mTransactionID;
-	EWearableType		mType;
+	LLWearableType::EType		mType;
 
 	typedef std::map<S32, F32> param_map_t;
 	param_map_t mSavedVisualParamMap; // last saved version of visual params
diff --git a/indra/newview/llwearableitemslist.cpp b/indra/newview/llwearableitemslist.cpp
index dbea7b556d..d29d38018b 100644
--- a/indra/newview/llwearableitemslist.cpp
+++ b/indra/newview/llwearableitemslist.cpp
@@ -180,7 +180,7 @@ BOOL LLPanelBodyPartsListItem::postBuild()
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
-LLPanelDummyClothingListItem* LLPanelDummyClothingListItem::create(EWearableType w_type)
+LLPanelDummyClothingListItem* LLPanelDummyClothingListItem::create(LLWearableType::EType w_type)
 {
 	LLPanelDummyClothingListItem* list_item = new LLPanelDummyClothingListItem(w_type);
 	list_item->init();
@@ -213,7 +213,7 @@ BOOL LLPanelDummyClothingListItem::postBuild()
 	return TRUE;
 }
 
-LLPanelDummyClothingListItem::LLPanelDummyClothingListItem(EWearableType w_type)
+LLPanelDummyClothingListItem::LLPanelDummyClothingListItem(LLWearableType::EType w_type)
  : LLPanelWearableListItem(NULL)
  , mWearableType(w_type)
 {
@@ -224,26 +224,26 @@ void LLPanelDummyClothingListItem::init()
 	LLUICtrlFactory::getInstance()->buildPanel(this, "panel_dummy_clothing_list_item.xml");
 }
 
-typedef std::map<EWearableType, std::string> clothing_to_string_map_t;
+typedef std::map<LLWearableType::EType, std::string> clothing_to_string_map_t;
 
 clothing_to_string_map_t init_clothing_string_map()
 {
 	clothing_to_string_map_t w_map;
-	w_map.insert(std::make_pair(WT_SHIRT, "shirt_not_worn"));
-	w_map.insert(std::make_pair(WT_PANTS, "pants_not_worn"));
-	w_map.insert(std::make_pair(WT_SHOES, "shoes_not_worn"));
-	w_map.insert(std::make_pair(WT_SOCKS, "socks_not_worn"));
-	w_map.insert(std::make_pair(WT_JACKET, "jacket_not_worn"));
-	w_map.insert(std::make_pair(WT_GLOVES, "gloves_not_worn"));
-	w_map.insert(std::make_pair(WT_UNDERSHIRT, "undershirt_not_worn"));
-	w_map.insert(std::make_pair(WT_UNDERPANTS, "underpants_not_worn"));
-	w_map.insert(std::make_pair(WT_SKIRT, "skirt_not_worn"));
-	w_map.insert(std::make_pair(WT_ALPHA, "alpha_not_worn"));
-	w_map.insert(std::make_pair(WT_TATTOO, "tattoo_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_SHIRT, "shirt_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_PANTS, "pants_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_SHOES, "shoes_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_SOCKS, "socks_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_JACKET, "jacket_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_GLOVES, "gloves_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_UNDERSHIRT, "undershirt_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_UNDERPANTS, "underpants_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_SKIRT, "skirt_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_ALPHA, "alpha_not_worn"));
+	w_map.insert(std::make_pair(LLWearableType::WT_TATTOO, "tattoo_not_worn"));
 	return w_map;
 }
 
-std::string LLPanelDummyClothingListItem::wearableTypeToString(EWearableType w_type)
+std::string LLPanelDummyClothingListItem::wearableTypeToString(LLWearableType::EType w_type)
 {
 	static const clothing_to_string_map_t w_map = init_clothing_string_map();
 	static const std::string invalid_str = LLTrans::getString("invalid_not_worn");
diff --git a/indra/newview/llwearableitemslist.h b/indra/newview/llwearableitemslist.h
index 29532a15c1..14bca21b85 100644
--- a/indra/newview/llwearableitemslist.h
+++ b/indra/newview/llwearableitemslist.h
@@ -132,20 +132,20 @@ protected:
 class LLPanelDummyClothingListItem : public LLPanelWearableListItem
 {
 public:
-	static LLPanelDummyClothingListItem* create(EWearableType w_type);
+	static LLPanelDummyClothingListItem* create(LLWearableType::EType w_type);
 
 	/*virtual*/ void updateItem();
 	/*virtual*/ BOOL postBuild();
 
 protected:
-	LLPanelDummyClothingListItem(EWearableType w_type);
+	LLPanelDummyClothingListItem(LLWearableType::EType w_type);
 
 	/*virtual*/ void init();
 
-	static std::string wearableTypeToString(EWearableType w_type);
+	static std::string wearableTypeToString(LLWearableType::EType w_type);
 
 private:
-	EWearableType mWearableType;
+	LLWearableType::EType mWearableType;
 };
 
 /**
diff --git a/indra/newview/llwearablelist.cpp b/indra/newview/llwearablelist.cpp
index 20266706da..aedaeba42a 100644
--- a/indra/newview/llwearablelist.cpp
+++ b/indra/newview/llwearablelist.cpp
@@ -121,7 +121,7 @@ void LLWearableList::processGetAssetReply( const char* filename, const LLAssetID
 			bool res = wearable->importFile( fp );
 			if (!res)
 			{
-				if (wearable->getType() == WT_COUNT)
+				if (wearable->getType() == LLWearableType::WT_COUNT)
 				{
 					isNewWearable = TRUE;
 				}
@@ -228,14 +228,14 @@ LLWearable* LLWearableList::createCopy(const LLWearable* old_wearable, const std
 	return wearable;
 }
 
-LLWearable* LLWearableList::createNewWearable( EWearableType type )
+LLWearable* LLWearableList::createNewWearable( LLWearableType::EType type )
 {
 	lldebugs << "LLWearableList::createNewWearable()" << llendl;
 
 	LLWearable *wearable = generateNewWearable();
 	wearable->setType( type );
 	
-	std::string name = LLTrans::getString( LLWearableDictionary::getTypeDefaultNewName(wearable->getType()) );
+	std::string name = LLTrans::getString( LLWearableType::getTypeDefaultNewName(wearable->getType()) );
 	wearable->setName( name );
 
 	LLPermissions perm;
diff --git a/indra/newview/llwearablelist.h b/indra/newview/llwearablelist.h
index 5e564ba953..16ef11b8bd 100644
--- a/indra/newview/llwearablelist.h
+++ b/indra/newview/llwearablelist.h
@@ -61,7 +61,7 @@ public:
 								 void* userdata);
 
 	LLWearable*			createCopy(const LLWearable* old_wearable, const std::string& new_name = std::string());
-	LLWearable*			createNewWearable(EWearableType type);
+	LLWearable*			createNewWearable(LLWearableType::EType type);
 	
 	// Callback
 	static void	 	    processGetAssetReply(const char* filename, const LLAssetID& assetID, void* user_data, S32 status, LLExtStat ext_status);