For QAR-1710 : Server merge for QAR-1594 QAR-1643 QAR-1644 - "AVP Changes [SIM]"

svn merge -r 128022:128028 svn+ssh://svn.lindenlab.com/svn/linden/branches/avatar-pipeline/server__merge__trunk-r127980 to svn+ssh://svn.lindenlab.com/svn/linden/trunk

This is the server-side merge for inventory links, folder links&types, and landmark&callingcard permissions.

indra/llcommon/CMakeLists.txt

@@ -99,6 +99,7 @@ set(llcommon_HEADER_FILES
     lldefs.h
     lldependencies.h
     lldepthstack.h
+    lldictionary.h
     lldlinked.h
     lldqueueptr.h
     llendianswizzle.h

indra/llcommon/llassettype.cpp

@@ -33,145 +33,125 @@
 #include "linden_common.h"
 
 #include "llassettype.h"
+#include "lldictionary.h"
+#include "llmemory.h"
 
-#include "llstring.h"
-#include "lltimer.h"
+///----------------------------------------------------------------------------
+/// Class LLAssetType
+///----------------------------------------------------------------------------
+struct AssetEntry : public LLDictionaryEntry
+{
+	AssetEntry(const char *desc_name,
+			   const char *type_name, // 8 character limit!
+			   const char *human_name, // for decoding to human readable form; put any and as many printable characters you want in each one
+			   const char *category_name, // used by llinventorymodel when creating new categories
+			   EDragAndDropType dad_type,
+			   bool can_link, // can you create a link to this type?
+			   bool is_protected) // can the viewer change categories of this type?
+		:
+		LLDictionaryEntry(desc_name),
+		mTypeName(type_name),
+		mHumanName(human_name),
+		mCategoryName(category_name),
+		mDadType(dad_type),
+		mCanLink(can_link),
+		mIsProtected(is_protected)
+	{
+		llassert(strlen(mTypeName) <= 8);
+	}
 
-// I added lookups for exact text of asset type enums in addition to the ones below, so shoot me. -Steve
+	const char *mTypeName;
+	const char *mHumanName;
+	const char *mCategoryName;
+	EDragAndDropType mDadType;
+	bool mCanLink;
+	bool mIsProtected;
+};
 
-struct asset_info_t
+class LLAssetDictionary : public LLSingleton<LLAssetDictionary>,
+						  public LLDictionary<LLAssetType::EType, AssetEntry>
 {
-	LLAssetType::EType type;
-	const char* desc;
+public:
+	LLAssetDictionary();
 };
 
-asset_info_t asset_types[] =
+LLAssetDictionary::LLAssetDictionary()
 {
-	{ LLAssetType::AT_TEXTURE, "TEXTURE" },
-	{ LLAssetType::AT_SOUND, "SOUND" },
-	{ LLAssetType::AT_CALLINGCARD, "CALLINGCARD" },
-	{ LLAssetType::AT_LANDMARK, "LANDMARK" },
-	{ LLAssetType::AT_SCRIPT, "SCRIPT" },
-	{ LLAssetType::AT_CLOTHING, "CLOTHING" },
-	{ LLAssetType::AT_OBJECT, "OBJECT" },
-	{ LLAssetType::AT_NOTECARD, "NOTECARD" },
-	{ LLAssetType::AT_CATEGORY, "CATEGORY" },
-	{ LLAssetType::AT_ROOT_CATEGORY, "ROOT_CATEGORY" },
-	{ LLAssetType::AT_LSL_TEXT, "LSL_TEXT" },
-	{ LLAssetType::AT_LSL_BYTECODE, "LSL_BYTECODE" },
-	{ LLAssetType::AT_TEXTURE_TGA, "TEXTURE_TGA" },
-	{ LLAssetType::AT_BODYPART, "BODYPART" },
-	{ LLAssetType::AT_TRASH, "TRASH" },
-	{ LLAssetType::AT_SNAPSHOT_CATEGORY, "SNAPSHOT_CATEGORY" },
-	{ LLAssetType::AT_LOST_AND_FOUND, "LOST_AND_FOUND" },
-	{ LLAssetType::AT_SOUND_WAV, "SOUND_WAV" },
-	{ LLAssetType::AT_IMAGE_TGA, "IMAGE_TGA" },
-	{ LLAssetType::AT_IMAGE_JPEG, "IMAGE_JPEG" },
-	{ LLAssetType::AT_ANIMATION, "ANIMATION" },
-	{ LLAssetType::AT_GESTURE, "GESTURE" },
-	{ LLAssetType::AT_SIMSTATE, "SIMSTATE" },
-	{ LLAssetType::AT_NONE, "NONE" },
+	//       												   DESCRIPTION			TYPE NAME	HUMAN NAME			CATEGORY NAME 		DRAG&DROP		CAN LINK?	PROTECTED?
+	//      												  |--------------------|-----------|-------------------|-------------------|---------------|-----------|-----------|
+	addEntry(LLAssetType::AT_TEXTURE, 			new AssetEntry("TEXTURE",			"texture",	"texture",			"Textures", 		DAD_TEXTURE,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_SOUND, 			new AssetEntry("SOUND",				"sound",	"sound",			"Sounds", 			DAD_SOUND,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_CALLINGCARD, 		new AssetEntry("CALLINGCARD",		"callcard",	"calling card",		"Calling Cards", 	DAD_CALLINGCARD, FALSE,		TRUE));
+	addEntry(LLAssetType::AT_LANDMARK, 			new AssetEntry("LANDMARK",			"landmark",	"landmark",			"Landmarks", 		DAD_LANDMARK,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_SCRIPT, 			new AssetEntry("SCRIPT",			"script",	"legacy script",	"Scripts", 			DAD_NONE,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_CLOTHING, 			new AssetEntry("CLOTHING",			"clothing",	"clothing",			"Clothing", 		DAD_CLOTHING,	TRUE,		TRUE));
+	addEntry(LLAssetType::AT_OBJECT, 			new AssetEntry("OBJECT",			"object",	"object",			"Objects", 			DAD_OBJECT,		TRUE,		TRUE));
+	addEntry(LLAssetType::AT_NOTECARD, 			new AssetEntry("NOTECARD",			"notecard",	"note card",		"Notecards", 		DAD_NOTECARD,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_CATEGORY, 			new AssetEntry("CATEGORY",			"category",	"folder",			"New Folder", 		DAD_CATEGORY,	TRUE,		TRUE));
+	addEntry(LLAssetType::AT_ROOT_CATEGORY, 	new AssetEntry("ROOT_CATEGORY",		"root",		"root",				"Inventory", 		DAD_ROOT_CATEGORY, TRUE,	TRUE));
+	addEntry(LLAssetType::AT_LSL_TEXT, 			new AssetEntry("LSL_TEXT",			"lsltext",	"lsl2 script",		"Scripts", 			DAD_SCRIPT,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_LSL_BYTECODE, 		new AssetEntry("LSL_BYTECODE",		"lslbyte",	"lsl bytecode",		"Scripts", 			DAD_NONE,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_TEXTURE_TGA, 		new AssetEntry("TEXTURE_TGA",		"txtr_tga",	"tga texture",		"Uncompressed Images", DAD_NONE,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_BODYPART, 			new AssetEntry("BODYPART",			"bodypart",	"body part",		"Body Parts", 		DAD_BODYPART,	TRUE,		TRUE));
+	addEntry(LLAssetType::AT_TRASH, 			new AssetEntry("TRASH",				"trash",	"trash",			"Trash", 			DAD_NONE,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_SNAPSHOT_CATEGORY, new AssetEntry("SNAPSHOT_CATEGORY", "snapshot",	"snapshot",			"Photo Album", 		DAD_NONE,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_LOST_AND_FOUND, 	new AssetEntry("LOST_AND_FOUND", 	"lstndfnd",	"lost and found",	"Lost And Found", 	DAD_NONE,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_SOUND_WAV, 		new AssetEntry("SOUND_WAV",			"snd_wav",	"sound",			"Uncompressed SoundS", DAD_NONE,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_IMAGE_TGA, 		new AssetEntry("IMAGE_TGA",			"img_tga",	"targa image",		"Uncompressed Images", DAD_NONE,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_IMAGE_JPEG, 		new AssetEntry("IMAGE_JPEG",		"jpeg",		"jpeg image",		"Uncompressed Images", DAD_NONE,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_ANIMATION, 		new AssetEntry("ANIMATION",			"animatn",	"animation",		"Animations", 		DAD_ANIMATION,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_GESTURE, 			new AssetEntry("GESTURE",			"gesture",	"gesture",			"Gestures", 		DAD_GESTURE,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_SIMSTATE, 			new AssetEntry("SIMSTATE",			"simstate",	"simstate",			"New Folder", 		DAD_NONE,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_FAVORITE, 			new AssetEntry("FAVORITE",			"favorite",	"favorite",			"favorite", 		DAD_NONE,		FALSE,		TRUE));
+
+	addEntry(LLAssetType::AT_LINK, 				new AssetEntry("LINK",				"link",		"symbolic link",	"Link", 			DAD_LINK,		FALSE,		TRUE));
+	addEntry(LLAssetType::AT_LINK_FOLDER, 		new AssetEntry("FOLDER_LINK",		"link_f", 	"symbolic folder link", "New Folder", 	DAD_LINK,		FALSE,		TRUE));
+
+	for (S32 ensemble_num = S32(LLAssetType::AT_FOLDER_ENSEMBLE_START); 
+		 ensemble_num <= S32(LLAssetType::AT_FOLDER_ENSEMBLE_END); 
+		 ensemble_num++)
+	{
+		addEntry(LLAssetType::EType(ensemble_num), new AssetEntry("ENSEMBLE",		"ensemble", "ensemble", 		"New Folder", 		DAD_CATEGORY,	TRUE,		FALSE)); 
+	}
+
+	addEntry(LLAssetType::AT_CURRENT_OUTFIT, 	new AssetEntry("CURRENT",			"current",	"current outfit",	"Current Outfit", 	DAD_CATEGORY,	FALSE,		TRUE));
+	addEntry(LLAssetType::AT_OUTFIT, 			new AssetEntry("OUTFIT",			"outfit",	"outfit",			"Outfit", 			DAD_CATEGORY,	TRUE,		FALSE));
+	addEntry(LLAssetType::AT_MY_OUTFITS, 		new AssetEntry("MY_OUTFITS",		"my_otfts",	"my outfits",		"My Outfits", 		DAD_CATEGORY,	FALSE,		TRUE));
+		 
+	addEntry(LLAssetType::AT_NONE, 				new AssetEntry("NONE",				"-1",		NULL,		  		"New Folder", 		DAD_NONE,		FALSE,		FALSE));
 };
 
-LLAssetType::EType LLAssetType::getType(const std::string& sin)
+// static
+LLAssetType::EType LLAssetType::getType(const std::string& desc_name)
 {
-	std::string s = sin;
+	std::string s = desc_name;
 	LLStringUtil::toUpper(s);
-	for (S32 idx = 0; ;idx++)
-	{
-		asset_info_t* info = asset_types + idx;
-		if (info->type == LLAssetType::AT_NONE)
-			break;
-		if (s == info->desc)
-			return info->type;
-	}
-	return LLAssetType::AT_NONE;
+	return LLAssetDictionary::getInstance()->lookup(s);
 }
 
-std::string LLAssetType::getDesc(LLAssetType::EType type)
+// static
+const std::string &LLAssetType::getDesc(LLAssetType::EType asset_type)
 {
-	for (S32 idx = 0; ;idx++)
+	const AssetEntry *entry = LLAssetDictionary::getInstance()->lookup(asset_type);
+	if (entry)
+	{
+		return entry->mName;
+	}
+	else
 	{
-		asset_info_t* info = asset_types + idx;
-		if (type == info->type)
-			return info->desc;
-		if (info->type == LLAssetType::AT_NONE)
-			break;
+		static const std::string error_string = "BAD TYPE";
+		return error_string;
 	}
-	return "BAD TYPE";
 }
 
-//============================================================================
-
-// The asset type names are limited to 8 characters.
-// static
-const char* LLAssetType::mAssetTypeNames[LLAssetType::AT_COUNT] =
-{ 
-	"texture",
-	"sound",
-	"callcard",
-	"landmark",
-	"script",
-	"clothing",
-	"object",
-	"notecard",
-	"category",
-	"root",
-	"lsltext",
-	"lslbyte",
-	"txtr_tga",// Intentionally spelled this way.  Limited to eight characters.
-	"bodypart",
-	"trash",
-	"snapshot",
-	"lstndfnd",
-	"snd_wav",
-	"img_tga",
-	"jpeg",
-	"animatn",
-	"gesture",
-	"simstate"
-};
-
-// This table is meant for decoding to human readable form. Put any
-// and as many printable characters you want in each one.
-// See also llinventory.cpp INVENTORY_TYPE_HUMAN_NAMES
-const char* LLAssetType::mAssetTypeHumanNames[LLAssetType::AT_COUNT] =
-{ 
-	"texture",
-	"sound",
-	"calling card",
-	"landmark",
-	"legacy script",
-	"clothing",
-	"object",
-	"note card",
-	"folder",
-	"root",
-	"lsl2 script",
-	"lsl bytecode",
-	"tga texture",
-	"body part",
-	"trash",
-	"snapshot",
-	"lost and found",
-	"sound",
-	"targa image",
-	"jpeg image",
-	"animation",
-	"gesture",
-	"simstate"
-};
-
-///----------------------------------------------------------------------------
-/// class LLAssetType
-///----------------------------------------------------------------------------
-
 // static
-const char* LLAssetType::lookup( LLAssetType::EType type )
+const char *LLAssetType::lookup(LLAssetType::EType asset_type)
 {
-	if( (type >= 0) && (type < AT_COUNT ))
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	const AssetEntry *entry = dict->lookup(asset_type);
+	if (entry)
 	{
-		return mAssetTypeNames[ S32( type ) ];
+		return entry->mTypeName;
 	}
 	else
 	{
@@ -180,30 +160,35 @@ const char* LLAssetType::lookup( LLAssetType::EType type )
 }
 
 // static
-LLAssetType::EType LLAssetType::lookup( const char* name )
+LLAssetType::EType LLAssetType::lookup(const char* name)
 {
 	return lookup(ll_safe_string(name));
 }
 
-LLAssetType::EType LLAssetType::lookup( const std::string& name )
+LLAssetType::EType LLAssetType::lookup(const std::string& type_name)
 {
-	for( S32 i = 0; i < AT_COUNT; i++ )
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	for (LLAssetDictionary::const_iterator iter = dict->begin();
+		 iter != dict->end();
+		 iter++)
 	{
-		if( name == mAssetTypeNames[i] )
+		const AssetEntry *entry = iter->second;
+		if (type_name == entry->mTypeName)
 		{
-			// match
-			return (EType)i;
+			return iter->first;
 		}
 	}
 	return AT_NONE;
 }
 
 // static
-const char* LLAssetType::lookupHumanReadable(LLAssetType::EType type)
+const char *LLAssetType::lookupHumanReadable(LLAssetType::EType asset_type)
 {
-	if( (type >= 0) && (type < AT_COUNT ))
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	const AssetEntry *entry = dict->lookup(asset_type);
+	if (entry)
 	{
-		return mAssetTypeHumanNames[S32(type)];
+		return entry->mHumanName;
 	}
 	else
 	{
@@ -212,49 +197,94 @@ const char* LLAssetType::lookupHumanReadable(LLAssetType::EType type)
 }
 
 // static
-LLAssetType::EType LLAssetType::lookupHumanReadable( const char* name )
+LLAssetType::EType LLAssetType::lookupHumanReadable(const char* name)
 {
 	return lookupHumanReadable(ll_safe_string(name));
 }
 
-LLAssetType::EType LLAssetType::lookupHumanReadable( const std::string& name )
+LLAssetType::EType LLAssetType::lookupHumanReadable(const std::string& readable_name)
 {
-	for( S32 i = 0; i < AT_COUNT; i++ )
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	for (LLAssetDictionary::const_iterator iter = dict->begin();
+		 iter != dict->end();
+		 iter++)
 	{
-		if( name == mAssetTypeHumanNames[i] )
+		const AssetEntry *entry = iter->second;
+		if (readable_name == entry->mHumanName)
 		{
-			// match
-			return (EType)i;
+			return iter->first;
 		}
 	}
 	return AT_NONE;
 }
 
-EDragAndDropType LLAssetType::lookupDragAndDropType( EType asset )
+// static
+const char *LLAssetType::lookupCategoryName(LLAssetType::EType asset_type)
+{
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	const AssetEntry *entry = dict->lookup(asset_type);
+	if (entry)
+	{
+		return entry->mCategoryName;
+	}
+	else
+	{
+		return "New Folder";
+	}
+}
+
+// static
+EDragAndDropType LLAssetType::lookupDragAndDropType(EType asset_type)
+{
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	const AssetEntry *entry = dict->lookup(asset_type);
+	if (entry)
+		return entry->mDadType;
+	else
+		return DAD_NONE;
+}
+
+// static
+bool LLAssetType::lookupCanLink(EType asset_type)
+{
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	const AssetEntry *entry = dict->lookup(asset_type);
+	if (entry)
+	{
+		return entry->mCanLink;
+	}
+	return false;
+}
+
+// static
+// Not adding this to dictionary since we probably will only have these two types
+bool LLAssetType::lookupIsLinkType(EType asset_type)
+{
+	if (asset_type == AT_LINK || asset_type == AT_LINK_FOLDER)
+	{
+		return true;
+	}
+	return false;
+}
+
+// static
+// Only ensembles and plain folders aren't protected.  "Protected" means
+// you can't change certain properties such as their type.
+bool LLAssetType::lookupIsProtectedCategoryType(EType asset_type)
 {
-	switch( asset )
+	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	const AssetEntry *entry = dict->lookup(asset_type);
+	if (entry)
 	{
-	case AT_TEXTURE:		return DAD_TEXTURE;
-	case AT_SOUND:			return DAD_SOUND;
-	case AT_CALLINGCARD:	return DAD_CALLINGCARD;
-	case AT_LANDMARK:		return DAD_LANDMARK;
-	case AT_SCRIPT:			return DAD_NONE;
-	case AT_CLOTHING:		return DAD_CLOTHING;
-	case AT_OBJECT:			return DAD_OBJECT;
-	case AT_NOTECARD:		return DAD_NOTECARD;
-	case AT_CATEGORY:		return DAD_CATEGORY;
-	case AT_ROOT_CATEGORY:	return DAD_ROOT_CATEGORY;
-	case AT_LSL_TEXT:		return DAD_SCRIPT;
-	case AT_BODYPART:		return DAD_BODYPART;
-	case AT_ANIMATION:		return DAD_ANIMATION;
-	case AT_GESTURE:		return DAD_GESTURE;
-	default: 				return DAD_NONE;
-	};
+		return entry->mIsProtected;
+	}
+	return true;
 }
 
+
 // static. Generate a good default description
-void LLAssetType::generateDescriptionFor(LLAssetType::EType type,
-										 std::string& desc)
+void LLAssetType::generateDescriptionFor(LLAssetType::EType asset_type,
+										 std::string& description)
 {
 	const S32 BUF_SIZE = 30;
 	char time_str[BUF_SIZE];	/* Flawfinder: ignore */
@@ -262,6 +292,6 @@ void LLAssetType::generateDescriptionFor(LLAssetType::EType type,
 	time(&now);
 	memset(time_str, '\0', BUF_SIZE);
 	strftime(time_str, BUF_SIZE - 1, "%Y-%m-%d %H:%M:%S ", localtime(&now));
-	desc.assign(time_str);
-	desc.append(LLAssetType::lookupHumanReadable(type));
+	description.assign(time_str);
+	description.append(LLAssetType::lookupHumanReadable(asset_type));
 }

indra/llcommon/llassettype.h

@@ -30,8 +30,8 @@
  * $/LicenseInfo$
  */
 
-#ifndef LL_LLASSETTYPE
-#define LL_LLASSETTYPE
+#ifndef LL_LLASSETTYPE_H
+#define LL_LLASSETTYPE_H
 
 #include <string>
 
@@ -42,137 +42,163 @@ class LLAssetType
 public:
 	enum EType
 	{
-		// Used for painting the faces of geometry.
-		// Stored in typical j2c stream format
 		AT_TEXTURE = 0,
+			// Used for painting the faces of geometry.
+			// Stored in typical j2c stream format.
 
-		// Used to fill the aural spectrum.
 		AT_SOUND = 1, 
+			// Used to fill the aural spectrum.
 
-		// Links instant message access to the user on the card. eg, a
-		// card for yourself, a card for linden support, a card for
-		// the guy you were talking to in the coliseum.
 		AT_CALLINGCARD = 2,
+		    // Links instant message access to the user on the card.
+			// : E.G. A card for yourself, for linden support, for
+			// : the guy you were talking to in the coliseum.
 
-		// Links to places in the world with location and a screen
-		// shot or image saved. eg, home, linden headquarters, the
-		// coliseum, or destinations where we want to increase
-		// traffic.
 		AT_LANDMARK = 3,
+			// Links to places in the world with location and a screen shot or image saved.
+			// : E.G. Home, linden headquarters, the coliseum, destinations where 
+			// : we want to increase traffic.
 
-		// Valid scripts that can be attached to an object. eg. open a
-		// door, jump into the air.
 		AT_SCRIPT = 4,
+			// Valid scripts that can be attached to an object.
+			// : E.G. Open a door, jump into the air.
 
-		// A collection of textures and parameters that can be worn
-		// by an avatar.
 		AT_CLOTHING = 5,
+			// A collection of textures and parameters that can be worn by an avatar.
 
-		// Any combination of textures, sounds, and scripts that are
-		// associated with a fixed piece of geometry. eg, a hot tub, a
-		// house with working door.
 		AT_OBJECT = 6,
+			// Any combination of textures, sounds, and scripts that are
+			// associated with a fixed piece of geometry.
+			// : E.G. A hot tub, a house with working door.
 
-		// Just text
 		AT_NOTECARD = 7,
+			// Just text.
 
-		// A category holds a collection of inventory items. It's
-		// treated as an item in the inventory, and therefore needs a
-		// type.
 		AT_CATEGORY = 8,
+			// Holds a collection of inventory items.
+			// It's treated as an item in the inventory and therefore needs a type.
 
-		// A root category is a user's root inventory category. We
-		// decided to expose it visually, so it seems logical to fold
-		// it into the asset types.
 		AT_ROOT_CATEGORY = 9,
+			// A user's root inventory category.
+			// We decided to expose it visually, so it seems logical to fold
+			// it into the asset types.
 
-		// The LSL is the brand spanking new scripting language. We've
-		// split it into a text and bytecode representation.
 		AT_LSL_TEXT = 10,
 		AT_LSL_BYTECODE = 11,
+			// The LSL is the scripting language. 
+			// We've split it into a text and bytecode representation.
 		
-		// uncompressed TGA texture
 		AT_TEXTURE_TGA = 12,
+			// Uncompressed TGA texture.
 
-		// A collection of textures and parameters that can be worn
-		// by an avatar.
 		AT_BODYPART = 13,
+			// A collection of textures and parameters that can be worn by an avatar.
 
-		// This asset type is meant to only be used as a marker for a
-		// category preferred type. Using this, we can throw things in
-		// the trash before completely deleting.
 		AT_TRASH = 14,
+			// Only to be used as a marker for a category preferred type. 
+			// Using this, we can throw things in the trash before completely deleting.
 
-		// This is a marker for a folder meant for snapshots. No
-		// actual assets will be snapshots, though if there were, you
-		// could interpret them as textures.
 		AT_SNAPSHOT_CATEGORY = 15,
+			// A marker for a folder meant for snapshots. 
+			// No actual assets will be snapshots, though if there were, you
+			// could interpret them as textures.
 
-		// This is used to stuff lost&found items into
 		AT_LOST_AND_FOUND = 16,
+			// Used to stuff lost&found items into.
 
-		// uncompressed sound
 		AT_SOUND_WAV = 17,
+			// Uncompressed sound.
 
-		// uncompressed image, non-square, and not appropriate for use
-		// as a texture.
 		AT_IMAGE_TGA = 18,
+			// Uncompressed image, non-square.
+			// Not appropriate for use as a texture.
 
-		// compressed image, non-square, and not appropriate for use
-		// as a texture.
 		AT_IMAGE_JPEG = 19,
+			// Compressed image, non-square.
+			// Not appropriate for use as a texture.
 
-		// animation
 		AT_ANIMATION = 20,
+			// Animation.
 
-		// gesture, sequence of animations, sounds, chat, wait steps
 		AT_GESTURE = 21,
+			// Gesture, sequence of animations, sounds, chat, wait steps.
 
-		// simstate file
 		AT_SIMSTATE = 22,
+			// Simstate file.
 
-		// +*********************************************+
-		// |  TO ADD AN ELEMENT TO THIS ENUM:            |
-		// +*********************************************+
-		// | 1. INSERT BEFORE AT_COUNT                   |
-		// | 2. INCREMENT AT_COUNT BY 1                  |
-		// | 3. ADD TO LLAssetType::mAssetTypeNames      |
-		// | 4. ADD TO LLAssetType::mAssetTypeHumanNames |
-		// +*********************************************+
+		AT_FAVORITE = 23,
+			// favorite items
 
-		AT_COUNT = 23,
+		AT_LINK = 24,
+			// Inventory symbolic link
+
+		AT_LINK_FOLDER = 25,
+			// Inventory folder link
+
+		AT_FOLDER_ENSEMBLE_START = 26,
+		AT_FOLDER_ENSEMBLE_END = 45,
+			// This range is reserved for special clothing folder types.
+
+		AT_CURRENT_OUTFIT = 46,
+			// Current outfit
+
+		AT_OUTFIT = 47,
+			// Predefined outfit ("look")
+
+		AT_MY_OUTFITS = 48,
+			// Folder that holds your outfits.
+
+		
+		AT_COUNT = 49,
+
+			// +*********************************************************+
+			// |  TO ADD AN ELEMENT TO THIS ENUM:                        |
+			// +*********************************************************+
+			// | 1. INSERT BEFORE AT_COUNT                               |
+			// | 2. INCREMENT AT_COUNT BY 1                              |
+			// | 3. ADD TO LLAssetDictionary in LLAssetType.cpp          |
+			// | 3. ADD TO DEFAULT_ASSET_FOR_INV in LLInventoryType.cpp  |
+			// +*********************************************************+
 
 		AT_NONE = -1
 	};
 
 	// machine transation between type and strings
-	static EType lookup(const char* name); // safe conversion to std::string, *TODO: deprecate
-	static EType lookup(const std::string& name);
-	static const char* lookup(EType type);
+	static EType 				lookup(const char* name); // safe conversion to std::string, *TODO: deprecate
+	static EType 				lookup(const std::string& type_name);
+	static const char*			lookup(EType asset_type);
 
 	// translation from a type to a human readable form.
-	static EType lookupHumanReadable( const char* name ); // safe conversion to std::string, *TODO: deprecate
-	static EType lookupHumanReadable( const std::string& name );
-	static const char* lookupHumanReadable(EType type);
-
-	static EDragAndDropType lookupDragAndDropType( EType );
+	static EType 				lookupHumanReadable(const char* desc_name); // safe conversion to std::string, *TODO: deprecate
+	static EType 				lookupHumanReadable(const std::string& readable_name);
+	static const char*			lookupHumanReadable(EType asset_type);
 
 	// Generate a good default description. You may want to add a verb
 	// or agent name after this depending on your application.
-	static void generateDescriptionFor(LLAssetType::EType type,
-									   std::string& desc);
+	static void 				generateDescriptionFor(LLAssetType::EType asset_type,
+													   std::string& description);
+
+	static EType 				getType(const std::string& desc_name);
+	static const std::string&	getDesc(EType asset_type);
+	static EDragAndDropType   	lookupDragAndDropType(EType asset_type);
+
+	static bool 				lookupCanLink(EType asset_type);
+	static bool 				lookupIsLinkType(EType asset_type);
 
-	static EType getType(const std::string& sin);
-	static std::string getDesc(EType type);
+	static const char*  		lookupCategoryName(EType asset_type);
+	static bool 				lookupIsProtectedCategoryType(EType asset_type);
+
+	/* TODO: Change return types from "const char *" to "const std::string &".
+	This is fairly straightforward, but requires changing some calls to use .c_str().
+	e.g.:
+	-	fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType));
+	+	fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType).c_str());
+	*/
 	
 private:
 	// don't instantiate or derive one of these objects
 	LLAssetType( void ) {}
 	~LLAssetType( void ) {}
-
-private:
-	static const char* mAssetTypeNames[];
-	static const char* mAssetTypeHumanNames[];
 };
 
-#endif // LL_LLASSETTYPE
+#endif // LL_LLASSETTYPE_H

indra/llcommon/lldictionary.h

+/** 
+ * @file lldictionary.h
+ * @brief Lldictionary class header file
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLDICTIONARY_H
+#define LL_LLDICTIONARY_H
+
+#include <map>
+
+struct LLDictionaryEntry
+{
+	LLDictionaryEntry(const std::string &name) :
+		mName(name)
+	{
+		mNameCapitalized = mName;
+		LLStringUtil::replaceChar(mNameCapitalized, '-', ' ');
+		LLStringUtil::replaceChar(mNameCapitalized, '_', ' ');
+		for (U32 i=0; i < mNameCapitalized.size(); i++)
+		{
+			if (i == 0 || mNameCapitalized[i-1] == ' ') // don't change ordering of this statement or crash
+			{
+				mNameCapitalized[i] = toupper(mNameCapitalized[i]);
+			}
+		}
+	}
+	virtual ~LLDictionaryEntry() {}
+	const std::string mName;
+	std::string mNameCapitalized;
+};
+
+template <class Index, class Entry>
+class LLDictionary : public std::map<Index, Entry *>
+{
+public:
+	typedef std::map<Index, Entry *> map_t;
+	typedef typename map_t::iterator iterator_t;
+	typedef typename map_t::const_iterator const_iterator_t;
+	
+	LLDictionary() {}
+	virtual ~LLDictionary()
+	{
+		for (iterator_t iter = map_t::begin(); iter != map_t::end(); ++iter)
+			delete (iter->second);
+	}
+
+	const Entry *lookup(Index index) const
+	{
+		const_iterator_t dictionary_iter = map_t::find(index);
+		if (dictionary_iter == map_t::end()) return NULL;
+		return dictionary_iter->second;
+	}
+	const Index lookup(const std::string &name) const 
+	{
+		for (const_iterator_t dictionary_iter = map_t::begin();
+			 dictionary_iter != map_t::end();
+			 dictionary_iter++)
+		{
+			const Entry *entry = dictionary_iter->second;
+			if (entry->mName == name)
+			{
+				return dictionary_iter->first;
+			}
+		}
+		llassert(false);
+		return Index(-1);
+	}
+
+protected:
+	void addEntry(Index index, Entry *entry)
+	{
+		if (lookup(index))
+		{
+			llerrs << "Dictionary entry already added (attempted to add duplicate entry)" << llendl;
+		}
+		(*this)[index] = entry;
+	}
+};
+
+#endif // LL_LLDICTIONARY_H

indra/llcommon/stdenums.h

@@ -54,7 +54,8 @@ enum EDragAndDropType
 	DAD_BODYPART		= 11,
 	DAD_ANIMATION		= 12,
 	DAD_GESTURE			= 13,
-	DAD_COUNT			= 14,   // number of types in this enum
+	DAD_LINK			= 14,
+	DAD_COUNT			= 15,   // number of types in this enum
 };
 
 // Reasons for drags to be denied.

indra/llinventory/llinventory.cpp

@@ -126,6 +126,20 @@ const std::string& LLInventoryObject::getName() const
 	return mName;
 }
 
+// To bypass linked items, since llviewerinventory's getType
+// will return the linked-to item's type instead of this object's type.
+LLAssetType::EType LLInventoryObject::getActualType() const
+{
+	return mType;
+}
+
+// See LLInventoryItem override.
+// virtual
+const LLUUID& LLInventoryObject::getLinkedUUID() const
+{
+	return mUUID;
+}
+
 LLAssetType::EType LLInventoryObject::getType() const
 {
 	return mType;
@@ -296,6 +310,7 @@ LLInventoryItem::LLInventoryItem(
 {
 	LLStringUtil::replaceNonstandardASCII(mDescription, ' ');
 	LLStringUtil::replaceChar(mDescription, '|', ' ');
+	mPermissions.initMasks(inv_type);
 }
 
 LLInventoryItem::LLInventoryItem() :
@@ -333,6 +348,19 @@ void LLInventoryItem::copyItem(const LLInventoryItem* other)
 	mCreationDate = other->mCreationDate;
 }
 
+// If this is a linked item, then the UUID of the base object is
+// this item's assetID.
+// virtual
+const LLUUID& LLInventoryItem::getLinkedUUID() const
+{
+	if (LLAssetType::lookupIsLinkType(getActualType()))
+	{
+		return mAssetUUID;
+	}
+
+	return LLInventoryObject::getLinkedUUID();
+}
+
 const LLPermissions& LLInventoryItem::getPermissions() const
 {
 	return mPermissions;
@@ -405,6 +433,9 @@ void LLInventoryItem::setDescription(const std::string& d)
 void LLInventoryItem::setPermissions(const LLPermissions& perm)
 {
 	mPermissions = perm;
+
+	// Override permissions to unrestricted if this is a landmark
+	mPermissions.initMasks(mInventoryType);
 }
 
 void LLInventoryItem::setInventoryType(LLInventoryType::EType inv_type)
@@ -476,6 +507,7 @@ BOOL LLInventoryItem::unpackMessage(LLMessageSystem* msg, const char* block, S32
 	mType = static_cast<LLAssetType::EType>(type);
 	msg->getS8(block, "InvType", type, block_num);
 	mInventoryType = static_cast<LLInventoryType::EType>(type);
+	mPermissions.initMasks(mInventoryType);
 
 	msg->getU32Fast(block, _PREHASH_Flags, mFlags, block_num);
 
@@ -666,6 +698,9 @@ BOOL LLInventoryItem::importFile(LLFILE* fp)
 		lldebugs << "Resetting inventory type for " << mUUID << llendl;
 		mInventoryType = LLInventoryType::defaultForAssetType(mType);
 	}
+
+	mPermissions.initMasks(mInventoryType);
+
 	return success;
 }
 
@@ -705,8 +740,8 @@ BOOL LLInventoryItem::exportFile(LLFILE* fp, BOOL include_asset_key) const
 		fprintf(fp, "\t\tasset_id\t%s\n", uuid_str.c_str());
 	}
 	fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType));
-	const char* inv_type_str = LLInventoryType::lookup(mInventoryType);
-	if(inv_type_str) fprintf(fp, "\t\tinv_type\t%s\n", inv_type_str);
+	const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
+	if(!inv_type_str.empty()) fprintf(fp, "\t\tinv_type\t%s\n", inv_type_str.c_str());
 	fprintf(fp, "\t\tflags\t%08x\n", mFlags);
 	mSaleInfo.exportFile(fp);
 	fprintf(fp, "\t\tname\t%s|\n", mName.c_str());
@@ -869,6 +904,9 @@ BOOL LLInventoryItem::importLegacyStream(std::istream& input_stream)
 		lldebugs << "Resetting inventory type for " << mUUID << llendl;
 		mInventoryType = LLInventoryType::defaultForAssetType(mType);
 	}
+
+	mPermissions.initMasks(mInventoryType);
+
 	return success;
 }
 
@@ -908,8 +946,8 @@ BOOL LLInventoryItem::exportLegacyStream(std::ostream& output_stream, BOOL inclu
 		output_stream << "\t\tasset_id\t" << uuid_str << "\n";
 	}
 	output_stream << "\t\ttype\t" << LLAssetType::lookup(mType) << "\n";
-	const char* inv_type_str = LLInventoryType::lookup(mInventoryType);
-	if(inv_type_str) 
+	const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
+	if(!inv_type_str.empty()) 
 		output_stream << "\t\tinv_type\t" << inv_type_str << "\n";
 	std::string buffer;
 	buffer = llformat( "\t\tflags\t%08x\n", mFlags);
@@ -951,8 +989,8 @@ void LLInventoryItem::asLLSD( LLSD& sd ) const
 	}
 	sd[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(mType);
 	sd[INV_INVENTORY_TYPE_LABEL] = mInventoryType;
-	const char* inv_type_str = LLInventoryType::lookup(mInventoryType);
-	if(inv_type_str)
+	const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
+	if(!inv_type_str.empty())
 	{
 		sd[INV_INVENTORY_TYPE_LABEL] = inv_type_str;
 	}
@@ -1091,6 +1129,8 @@ bool LLInventoryItem::fromLLSD(const LLSD& sd)
 		mInventoryType = LLInventoryType::defaultForAssetType(mType);
 	}
 
+	mPermissions.initMasks(mInventoryType);
+
 	return true;
 fail:
 	return false;
@@ -1698,7 +1738,7 @@ LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat)
 	rv[INV_PARENT_ID_LABEL] = cat->getParentUUID();
 	rv[INV_NAME_LABEL] = cat->getName();
 	rv[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(cat->getType());
-	if(LLAssetType::AT_NONE != cat->getPreferredType())
+	if(LLAssetType::lookupIsProtectedCategoryType(cat->getPreferredType()))
 	{
 		rv[INV_PREFERRED_TYPE_LABEL] =
 			LLAssetType::lookup(cat->getPreferredType());

indra/llinventory/llinventory.h

@@ -91,8 +91,11 @@ class LLInventoryObject : public LLRefCount
 	// accessors
 	virtual const LLUUID& getUUID() const;
 	const LLUUID& getParentUUID() const;
-	const std::string& getName() const;
-	LLAssetType::EType getType() const;
+	virtual const LLUUID& getLinkedUUID() const; // get the inventoryID that this item points to, else this item's inventoryID
+
+	virtual const std::string& getName() const;
+	virtual LLAssetType::EType getType() const;
+	LLAssetType::EType getActualType() const; // bypasses indirection for linked items
 
 	// mutators - will not call updateServer();
 	void setUUID(const LLUUID& new_uuid);
@@ -238,15 +241,16 @@ class LLInventoryItem : public LLInventoryObject
 	void generateUUID() { mUUID.generate(); }
 	
 	// accessors
-	const LLPermissions& getPermissions() const;
-	const LLUUID& getCreatorUUID() const;
-	const LLUUID& getAssetUUID() const;
-	const std::string& getDescription() const;
-	const LLSaleInfo& getSaleInfo() const;
-	LLInventoryType::EType getInventoryType() const;
-	U32 getFlags() const;
-	time_t getCreationDate() const;
-	U32 getCRC32() const; // really more of a checksum.
+	virtual const LLUUID& getLinkedUUID() const;
+	virtual const LLPermissions& getPermissions() const;
+	virtual const LLUUID& getCreatorUUID() const;
+	virtual const LLUUID& getAssetUUID() const;
+	virtual const std::string& getDescription() const;
+	virtual const LLSaleInfo& getSaleInfo() const;
+	virtual LLInventoryType::EType getInventoryType() const;
+	virtual U32 getFlags() const;
+	virtual time_t getCreationDate() const;
+	virtual U32 getCRC32() const; // really more of a checksum.
 	
 	// mutators - will not call updateServer(), and will never fail
 	// (though it may correct to sane values)

indra/llinventory/llinventorytype.cpp

@@ -33,66 +33,72 @@
 #include "linden_common.h"
 
 #include "llinventorytype.h"
+#include "lldictionary.h"
+#include "llmemory.h"
+
+static const std::string empty_string;
 
 ///----------------------------------------------------------------------------
 /// Class LLInventoryType
 ///----------------------------------------------------------------------------
-
-// Unlike asset type names, not limited to 8 characters.
-// Need not match asset type names.
-static const char* INVENTORY_TYPE_NAMES[LLInventoryType::IT_COUNT] =
-{ 
-	"texture",      // 0
-	"sound",
-	"callcard",
-	"landmark",
-	NULL,
-	NULL,           // 5
-	"object",
-	"notecard",
-	"category",
-	"root",
-	"script",       // 10
-	NULL,
-	NULL,
-	NULL,
-	NULL,
-	"snapshot",     // 15
-	NULL,
-	"attach",
-	"wearable",
-	"animation",
-	"gesture",		// 20
+struct InventoryEntry : public LLDictionaryEntry
+{
+	InventoryEntry(const std::string &name, // unlike asset type names, not limited to 8 characters; need not match asset type names
+				   const std::string &human_name, // for decoding to human readable form; put any and as many printable characters you want in each one.
+				   int num_asset_types = 0, ...)
+		:
+		LLDictionaryEntry(name),
+		mHumanName(human_name)
+	{
+		va_list argp;
+		va_start(argp, num_asset_types);
+		// Read in local textures
+		for (U8 i=0; i < num_asset_types; i++)
+		{
+			LLAssetType::EType t = (LLAssetType::EType)va_arg(argp,int);
+			mAssetTypes.push_back(t);
+		}
+	}
+		
+	const std::string mHumanName;
+	typedef std::vector<LLAssetType::EType> asset_vec_t;
+	asset_vec_t mAssetTypes;
 };
 
-// This table is meant for decoding to human readable form. Put any
-// and as many printable characters you want in each one.
-// See also LLAssetType::mAssetTypeHumanNames
-static const char* INVENTORY_TYPE_HUMAN_NAMES[LLInventoryType::IT_COUNT] =
-{ 
-	"texture",      // 0
-	"sound",
-	"calling card",
-	"landmark",
-	NULL,
-	NULL,           // 5
-	"object",
-	"note card",
-	"folder",
-	"root",
-	"script",       // 10
-	NULL,
-	NULL,
-	NULL,
-	NULL,
-	"snapshot",     // 15
-	NULL,
-	"attachment",
-	"wearable",
-	"animation",
-	"gesture",		// 20
+class LLInventoryDictionary : public LLSingleton<LLInventoryDictionary>,
+							  public LLDictionary<LLInventoryType::EType, InventoryEntry>
+{
+public:
+	LLInventoryDictionary();
 };
 
+LLInventoryDictionary::LLInventoryDictionary()
+{
+	addEntry(LLInventoryType::IT_TEXTURE,             new InventoryEntry("texture",   "texture",       1, LLAssetType::AT_TEXTURE));
+	addEntry(LLInventoryType::IT_SOUND,               new InventoryEntry("sound",     "sound",         1, LLAssetType::AT_SOUND));
+	addEntry(LLInventoryType::IT_CALLINGCARD,         new InventoryEntry("callcard",  "calling card",  1, LLAssetType::AT_CALLINGCARD));
+	addEntry(LLInventoryType::IT_LANDMARK,            new InventoryEntry("landmark",  "landmark",      1, LLAssetType::AT_LANDMARK));
+	//addEntry(LLInventoryType::IT_SCRIPT,            new InventoryEntry(NULL,NULL));
+	//addEntry(LLInventoryType::IT_CLOTHING,          new InventoryEntry(NULL,NULL));
+	addEntry(LLInventoryType::IT_OBJECT,              new InventoryEntry("object",    "object",        1, LLAssetType::AT_OBJECT));
+	addEntry(LLInventoryType::IT_NOTECARD,            new InventoryEntry("notecard",  "note card",     1, LLAssetType::AT_NOTECARD));
+	addEntry(LLInventoryType::IT_CATEGORY,            new InventoryEntry("category",  "folder"         ));
+	addEntry(LLInventoryType::IT_ROOT_CATEGORY,       new InventoryEntry("root",      "root"           ));
+	addEntry(LLInventoryType::IT_LSL,                 new InventoryEntry("script",    "script",        2, LLAssetType::AT_LSL_TEXT, LLAssetType::AT_LSL_BYTECODE));
+	//addEntry(LLInventoryType::IT_LSL_BYTECODE,      new InventoryEntry(NULL,NULL));
+	//addEntry(LLInventoryType::IT_TEXTURE_TGA,       new InventoryEntry(NULL,NULL));
+	//addEntry(LLInventoryType::IT_BODYPART,          new InventoryEntry(NULL,NULL));
+	//addEntry(LLInventoryType::IT_TRASH,             new InventoryEntry(NULL,NULL));
+	addEntry(LLInventoryType::IT_SNAPSHOT,            new InventoryEntry("snapshot",  "snapshot",      1, LLAssetType::AT_TEXTURE));
+	//addEntry(LLInventoryType::IT_LOST_AND_FOUND,    new InventoryEntry(NULL,NULL, ));
+	addEntry(LLInventoryType::IT_ATTACHMENT,          new InventoryEntry("attach",    "attachment",    1, LLAssetType::AT_OBJECT));
+	addEntry(LLInventoryType::IT_WEARABLE,            new InventoryEntry("wearable",  "wearable",      2, LLAssetType::AT_CLOTHING, LLAssetType::AT_BODYPART));
+	addEntry(LLInventoryType::IT_ANIMATION,           new InventoryEntry("animation", "animation",     1, LLAssetType::AT_ANIMATION));  
+	addEntry(LLInventoryType::IT_GESTURE,             new InventoryEntry("gesture",   "gesture",       1, LLAssetType::AT_GESTURE)); 
+	addEntry(LLInventoryType::IT_FAVORITE,            new InventoryEntry("favorite",  "favorite",      1, LLAssetType::AT_FAVORITE)); 
+}
+
+
 // Maps asset types to the default inventory type for that kind of asset.
 // Thus, "Lost and Found" is a "Category"
 static const LLInventoryType::EType
@@ -120,76 +126,60 @@ DEFAULT_ASSET_FOR_INV_TYPE[LLAssetType::AT_COUNT] =
 	LLInventoryType::IT_NONE,			// AT_IMAGE_JPEG
 	LLInventoryType::IT_ANIMATION,		// AT_ANIMATION
 	LLInventoryType::IT_GESTURE,		// AT_GESTURE
-};
+	LLInventoryType::IT_NONE,			// AT_SIMSTATE
+	LLInventoryType::IT_FAVORITE,		// AT_FAVORITE
 
-static const int MAX_POSSIBLE_ASSET_TYPES = 2;
-static const LLAssetType::EType
-INVENTORY_TO_ASSET_TYPE[LLInventoryType::IT_COUNT][MAX_POSSIBLE_ASSET_TYPES] =
-{
-	{ LLAssetType::AT_TEXTURE, LLAssetType::AT_NONE },		// IT_TEXTURE
-	{ LLAssetType::AT_SOUND, LLAssetType::AT_NONE },		// IT_SOUND
-	{ LLAssetType::AT_CALLINGCARD, LLAssetType::AT_NONE },	// IT_CALLINGCARD
-	{ LLAssetType::AT_LANDMARK, LLAssetType::AT_NONE },		// IT_LANDMARK
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },
-	{ LLAssetType::AT_OBJECT, LLAssetType::AT_NONE },		// IT_OBJECT
-	{ LLAssetType::AT_NOTECARD, LLAssetType::AT_NONE },		// IT_NOTECARD
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },			// IT_CATEGORY
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },			// IT_ROOT_CATEGORY
-	{ LLAssetType::AT_LSL_TEXT, LLAssetType::AT_LSL_BYTECODE }, // IT_LSL
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },
-	{ LLAssetType::AT_TEXTURE, LLAssetType::AT_NONE },		// IT_SNAPSHOT
-	{ LLAssetType::AT_NONE, LLAssetType::AT_NONE },
-	{ LLAssetType::AT_OBJECT, LLAssetType::AT_NONE },		// IT_ATTACHMENT
-	{ LLAssetType::AT_CLOTHING, LLAssetType::AT_BODYPART },	// IT_WEARABLE
-	{ LLAssetType::AT_ANIMATION, LLAssetType::AT_NONE },	// IT_ANIMATION
-	{ LLAssetType::AT_GESTURE, LLAssetType::AT_NONE },		// IT_GESTURE
+	LLInventoryType::IT_NONE,			// AT_LINK
+	LLInventoryType::IT_NONE,			// AT_LINK_FOLDER
+
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+	LLInventoryType::IT_CATEGORY,		// AT_ENSEMBLE
+
+	LLInventoryType::IT_CATEGORY,		// AT_CURRENT_OUTFIT
+	LLInventoryType::IT_CATEGORY,		// AT_OUTFIT
+	LLInventoryType::IT_CATEGORY,		// AT_MY_OUTFITS
 };
 
 // static
-const char* LLInventoryType::lookup(EType type)
+const std::string &LLInventoryType::lookup(EType type)
 {
-	if((type >= 0) && (type < IT_COUNT))
-	{
-		return INVENTORY_TYPE_NAMES[S32(type)];
-	}
-	else
-	{
-		return NULL;
-	}
+	const InventoryEntry *entry = LLInventoryDictionary::getInstance()->lookup(type);
+	if (!entry) return empty_string;
+	return entry->mName;
 }
 
 // static
 LLInventoryType::EType LLInventoryType::lookup(const std::string& name)
 {
-	for(S32 i = 0; i < IT_COUNT; ++i)
-	{
-		if((INVENTORY_TYPE_NAMES[i])
-		   && (name == INVENTORY_TYPE_NAMES[i]))
-		{
-			// match
-			return (EType)i;
-		}
-	}
-	return IT_NONE;
+	return LLInventoryDictionary::getInstance()->lookup(name);
 }
 
 // XUI:translate
 // translation from a type to a human readable form.
 // static
-const char* LLInventoryType::lookupHumanReadable(EType type)
+const std::string &LLInventoryType::lookupHumanReadable(EType type)
 {
-	if((type >= 0) && (type < IT_COUNT))
-	{
-		return INVENTORY_TYPE_HUMAN_NAMES[S32(type)];
-	}
-	else
-	{
-		return NULL;
-	}
+	const InventoryEntry *entry = LLInventoryDictionary::getInstance()->lookup(type);
+	if (!entry) return empty_string;
+	return entry->mHumanName;
 }
 
 // return the default inventory for the given asset type.
@@ -206,21 +196,36 @@ LLInventoryType::EType LLInventoryType::defaultForAssetType(LLAssetType::EType a
 	}
 }
 
-bool inventory_and_asset_types_match(
-	LLInventoryType::EType inventory_type,
-	LLAssetType::EType asset_type)
+
+// add any types that we don't want the user to be able to change permissions on.
+// static
+bool LLInventoryType::cannotRestrictPermissions(LLInventoryType::EType type)
 {
-	bool rv = false;
-	if((inventory_type >= 0) && (inventory_type < LLInventoryType::IT_COUNT))
+	switch(type)
+	{
+		case IT_CALLINGCARD:
+		case IT_LANDMARK:
+			return true;
+		default:
+			return false;
+	}
+}
+
+bool inventory_and_asset_types_match(LLInventoryType::EType inventory_type,
+									 LLAssetType::EType asset_type)
+{
+	const InventoryEntry *entry = LLInventoryDictionary::getInstance()->lookup(inventory_type);
+	if (!entry) return false;
+
+	for (InventoryEntry::asset_vec_t::const_iterator iter = entry->mAssetTypes.begin();
+		 iter != entry->mAssetTypes.end();
+		 iter++)
 	{
-		for(S32 i = 0; i < MAX_POSSIBLE_ASSET_TYPES; ++i)
+		const LLAssetType::EType type = (*iter);
+		if(type == asset_type)
 		{
-			if(INVENTORY_TO_ASSET_TYPE[inventory_type][i] == asset_type)
-			{
-				rv = true;
-				break;
-			}
+			return true;
 		}
 	}
-	return rv;
+	return false;
 }

indra/llinventory/llinventorytype.h

@@ -67,21 +67,25 @@ class LLInventoryType
 		IT_WEARABLE = 18,
 		IT_ANIMATION = 19,
 		IT_GESTURE = 20,
-		IT_COUNT = 21,
+		IT_FAVORITE = 21,
+		IT_COUNT = 22,
 
 		IT_NONE = -1
 	};
 
 	// machine transation between type and strings
 	static EType lookup(const std::string& name);
-	static const char* lookup(EType type);
+	static const std::string &lookup(EType type);
 
 	// translation from a type to a human readable form.
-	static const char* lookupHumanReadable(EType type);
+	static const std::string &lookupHumanReadable(EType type);
 
 	// return the default inventory for the given asset type.
 	static EType defaultForAssetType(LLAssetType::EType asset_type);
 
+	// true if this type cannot have restricted permissions.
+	static bool cannotRestrictPermissions(EType type);
+
 private:
 	// don't instantiate or derive one of these objects
 	LLInventoryType( void );

indra/llinventory/llparcel.h

@@ -446,8 +446,10 @@ class LLParcel
 	BOOL	getAllowFly() const
 					{ return (mParcelFlags & PF_ALLOW_FLY) ? TRUE : FALSE; }
 
+	// Remove permission restrictions for creating landmarks.
+	// We should eventually remove this flag completely.
 	BOOL	getAllowLandmark() const
-					{ return (mParcelFlags & PF_ALLOW_LANDMARK) ? TRUE : FALSE; }
+					{ return TRUE; }
 
 	BOOL	getAllowGroupScripts() const
 					{ return (mParcelFlags & PF_ALLOW_GROUP_SCRIPTS) ? TRUE : FALSE; }

indra/llinventory/llpermissions.cpp

@@ -83,6 +83,17 @@ void LLPermissions::initMasks(PermissionMask base, PermissionMask owner,
 	fix();
 }
 
+// ! BACKWARDS COMPATIBILITY ! Override masks for inventory types that
+// no longer can have restricted permissions.  This takes care of previous
+// version landmarks that could have had no copy/mod/transfer bits set.
+void LLPermissions::initMasks(LLInventoryType::EType type)
+{
+	if (LLInventoryType::cannotRestrictPermissions(type))
+	{
+		initMasks(PERM_ALL, PERM_ALL, PERM_ALL, PERM_ALL, PERM_ALL);
+	}
+}
+
 BOOL LLPermissions::getOwnership(LLUUID& owner_id, BOOL& is_group_owned) const
 {
 	if(mOwner.notNull())

indra/llinventory/llpermissions.h

@@ -38,6 +38,7 @@
 #include "lluuid.h"
 #include "llxmlnode.h"
 #include "reflective.h"
+#include "llinventorytype.h"
 
 // prototypes
 class LLMessageSystem;
@@ -129,6 +130,8 @@ class LLPermissions : public LLReflective
 	void initMasks(PermissionMask base, PermissionMask owner,
 				   PermissionMask everyone, PermissionMask group,
 				   PermissionMask next);
+	// adjust permissions based on inventory type.
+	void initMasks(LLInventoryType::EType type);
 
 	//
 	// ACCESSORS

indra/llmessage/lltransfersourceasset.cpp

@@ -264,16 +264,17 @@ bool is_asset_fetch_by_id_allowed(LLAssetType::EType type)
 	bool rv = false;
 	switch(type)
 	{
-	case LLAssetType::AT_SOUND:
-	case LLAssetType::AT_LANDMARK:
-	case LLAssetType::AT_CLOTHING:
-	case LLAssetType::AT_BODYPART:
-	case LLAssetType::AT_ANIMATION:
-	case LLAssetType::AT_GESTURE:
-		rv = true;
-		break;
-	default:
-		break;
+		case LLAssetType::AT_SOUND:
+		case LLAssetType::AT_LANDMARK:
+		case LLAssetType::AT_CLOTHING:
+		case LLAssetType::AT_BODYPART:
+		case LLAssetType::AT_ANIMATION:
+		case LLAssetType::AT_GESTURE:
+		case LLAssetType::AT_FAVORITE:
+			rv = true;
+			break;
+		default:
+			break;
 	}
 	return rv;
 }
@@ -284,18 +285,21 @@ bool is_asset_id_knowable(LLAssetType::EType type)
 	bool rv = false;
 	switch(type)
 	{
-	case LLAssetType::AT_TEXTURE:
-	case LLAssetType::AT_SOUND:
-	case LLAssetType::AT_LANDMARK:
-	case LLAssetType::AT_CLOTHING:
-	case LLAssetType::AT_NOTECARD:
-	case LLAssetType::AT_BODYPART:
-	case LLAssetType::AT_ANIMATION:
-	case LLAssetType::AT_GESTURE:
-		rv = true;
-		break;
-	default:
-		break;
+		case LLAssetType::AT_TEXTURE:
+		case LLAssetType::AT_SOUND:
+		case LLAssetType::AT_LANDMARK:
+		case LLAssetType::AT_CLOTHING:
+		case LLAssetType::AT_NOTECARD:
+		case LLAssetType::AT_BODYPART:
+		case LLAssetType::AT_ANIMATION:
+		case LLAssetType::AT_GESTURE:
+		case LLAssetType::AT_FAVORITE:
+		case LLAssetType::AT_LINK:
+		case LLAssetType::AT_LINK_FOLDER:
+			rv = true;
+			break;
+		default:
+			break;
 	}
 	return rv;
 }

indra/llmessage/message_prehash.cpp

@@ -174,6 +174,7 @@ char* _PREHASH_UpdateInventoryItem = LLMessageStringTable::getInstance()->getStr
 char* _PREHASH_UpdateCreateInventoryItem = LLMessageStringTable::getInstance()->getString("UpdateCreateInventoryItem");
 char* _PREHASH_MoveInventoryItem = LLMessageStringTable::getInstance()->getString("MoveInventoryItem");
 char* _PREHASH_CopyInventoryItem = LLMessageStringTable::getInstance()->getString("CopyInventoryItem");
+char* _PREHASH_LinkInventoryItem = LLMessageStringTable::getInstance()->getString("LinkInventoryItem");
 char* _PREHASH_RemoveInventoryItem = LLMessageStringTable::getInstance()->getString("RemoveInventoryItem");
 char* _PREHASH_CreateInventoryItem = LLMessageStringTable::getInstance()->getString("CreateInventoryItem");
 char* _PREHASH_PathTwistBegin = LLMessageStringTable::getInstance()->getString("PathTwistBegin");

indra/llmessage/message_prehash.h

@@ -174,6 +174,7 @@ extern char * _PREHASH_UpdateInventoryItem;
 extern char * _PREHASH_UpdateCreateInventoryItem;
 extern char * _PREHASH_MoveInventoryItem;
 extern char * _PREHASH_CopyInventoryItem;
+extern char * _PREHASH_LinkInventoryItem;
 extern char * _PREHASH_RemoveInventoryItem;
 extern char * _PREHASH_CreateInventoryItem;
 extern char * _PREHASH_PathTwistBegin;

indra/newview/llinventorybridge.cpp

@@ -602,13 +602,12 @@ void LLInvFVBridge::changeCategoryParent(LLInventoryModel* model,
 }
 
 
-const char* safe_inv_type_lookup(LLInventoryType::EType inv_type)
+const std::string safe_inv_type_lookup(LLInventoryType::EType inv_type)
 {
-	const char* rv = LLInventoryType::lookup(inv_type);
-	if(!rv)
+	const std::string rv= LLInventoryType::lookup(inv_type);
+	if(rv.empty())
 	{
-		const char* INVALID_TYPE = "<invalid>";
-		rv = INVALID_TYPE;
+		return std::string("<invalid>");
 	}
 	return rv;
 }

indra/newview/llviewerinventory.cpp

@@ -307,8 +307,8 @@ bool LLViewerInventoryItem::exportFileLocal(LLFILE* fp) const
 	fprintf(fp, "\t\tparent_id\t%s\n", uuid_str.c_str());
 	mPermissions.exportFile(fp);
 	fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType));
-	const char* inv_type_str = LLInventoryType::lookup(mInventoryType);
-	if(inv_type_str) fprintf(fp, "\t\tinv_type\t%s\n", inv_type_str);
+	const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
+	if(!inv_type_str.empty()) fprintf(fp, "\t\tinv_type\t%s\n", inv_type_str.c_str());
 	fprintf(fp, "\t\tname\t%s|\n", mName.c_str());
 	fprintf(fp, "\t\tcreation_date\t%d\n", (S32) mCreationDate);
 	fprintf(fp,"\t}\n");

scripts/messages/message_template.msg

@@ -8945,3 +8945,21 @@ version 2.0
 		{	CRC				U32	}
 	}
 }
+
+{
+	LinkInventoryItem	Low	426 NotTrusted	Zerocoded
+	{
+		AgentData		Single
+		{	AgentID		LLUUID	}
+		{	SessionID	LLUUID	}
+	}
+	{
+		InventoryData		Variable
+		{	CallbackID	U32			} // Async Response
+		{	FolderID		LLUUID	}
+		{	OldItemID		LLUUID	}
+		{	Name			Variable	1	}
+		{	AssetType		U8		}
+	}
+}
+