Update to LLAvatarNameCache and consumers.

2012-12-08 00:59:37 -06:00
parent 9fb4e677a6
commit 3ba967bdc1
21 changed files with 646 additions and 339 deletions
--- a/indra/newview/llfloateravatarpicker.cpp
+++ b/indra/newview/llfloateravatarpicker.cpp
@@ -37,17 +37,20 @@

 #include "llagent.h"
 #include "llbutton.h"
+#include "llcachename.h"
 #include "llfocusmgr.h"
 #include "llfoldervieweventlistener.h"
 #include "llinventorypanel.h"
 #include "llinventorymodel.h"
 #include "llinventoryfunctions.h"
+#include "llavatarnamecache.h"	// IDEVO
 #include "lllineeditor.h"
 #include "llscrolllistctrl.h"
 #include "lltextbox.h"
 #include "lluictrlfactory.h"
 #include "llviewercontrol.h"
 #include "llworld.h"
+#include "llviewerregion.h"

 // [RLVa:KB]
 #include "rlvhandler.h"
@@ -60,45 +63,36 @@ const std::string FLOATER_TITLE = "Choose Resident";

 // static
 LLFloaterAvatarPicker* LLFloaterAvatarPicker::sInstance = NULL;
+static std::map<LLUUID, LLAvatarName> sAvatarNameMap;

-
-LLFloaterAvatarPicker* LLFloaterAvatarPicker::show(callback_t callback, 
-												   void* userdata,
+LLFloaterAvatarPicker* LLFloaterAvatarPicker::show(select_callback_t callback,
 												   BOOL allow_multiple,
 												   BOOL closeOnSelect)
 {
 	// TODO: This class should not be a singleton as it's used in multiple places
 	// and therefore can't be used simultaneously. -MG
-	if (!sInstance)
+	
+	LLFloaterAvatarPicker* floater = sInstance ? sInstance : new LLFloaterAvatarPicker();
+	floater->open();	/* Flawfinder: ignore */
+	if(!sInstance)
 	{
-		sInstance = new LLFloaterAvatarPicker();
-		sInstance->mCallback = callback;
-		sInstance->mCallbackUserdata = userdata;
-		sInstance->mCloseOnSelect = FALSE;
-
-		sInstance->open();	/* Flawfinder: ignore */
-		sInstance->center();
-		sInstance->setAllowMultiple(allow_multiple);
-	}
-	else
-	{
-		sInstance->open();	/*Flawfinder: ignore*/
-		sInstance->mCallback = callback;
-		sInstance->mCallbackUserdata = userdata;
-		sInstance->setAllowMultiple(allow_multiple);
+		sInstance = floater;
+		floater->center();
 	}
 	
-	sInstance->mNearMeListComplete = FALSE;
-	sInstance->mCloseOnSelect = closeOnSelect;
-	return sInstance;
+	floater->mSelectionCallback = callback;
+	floater->setAllowMultiple(allow_multiple);
+	floater->mNearMeListComplete = FALSE;
+	floater->mCloseOnSelect = closeOnSelect;
+	return floater;
 }

 // Default constructor
 LLFloaterAvatarPicker::LLFloaterAvatarPicker() :
 	LLFloater(std::string("avatarpicker"), FLOATER_RECT, FLOATER_TITLE, TRUE, MIN_WIDTH, MIN_HEIGHT),
-	mResultsReturned(FALSE),
-	mCallback(NULL),
-	mCallbackUserdata(NULL)
+	mNumResultsReturned(0),
+	mNearMeListComplete(FALSE),
+	mCloseOnSelect(FALSE)
 {
 	LLUICtrlFactory::getInstance()->buildFloater(this, "floater_avatar_picker.xml", NULL);
 }
@@ -111,16 +105,16 @@ BOOL LLFloaterAvatarPicker::postBuild()
 	childSetAction("Find", boost::bind(&LLFloaterAvatarPicker::onBtnFind, this));
 	getChildView("Find")->setEnabled(FALSE);
 	childSetAction("Refresh", boost::bind(&LLFloaterAvatarPicker::onBtnRefresh, this));
-	getChild<LLUICtrl>("near_me_range")->setCommitCallback(boost::bind(&LLFloaterAvatarPicker::onRangeAdjust, _1, this));
+	getChild<LLUICtrl>("near_me_range")->setCommitCallback(boost::bind(&LLFloaterAvatarPicker::onRangeAdjust, this));

 	LLScrollListCtrl* searchresults = getChild<LLScrollListCtrl>("SearchResults");
 	searchresults->setDoubleClickCallback( boost::bind(&LLFloaterAvatarPicker::onBtnSelect, this));
-	searchresults->setCommitCallback(boost::bind(&LLFloaterAvatarPicker::onList, _1, this));
+	searchresults->setCommitCallback(boost::bind(&LLFloaterAvatarPicker::onList, this));
 	getChildView("SearchResults")->setEnabled(FALSE);

 	LLScrollListCtrl* nearme = getChild<LLScrollListCtrl>("NearMe");
 	nearme->setDoubleClickCallback(boost::bind(&LLFloaterAvatarPicker::onBtnSelect, this));
-	nearme->setCommitCallback(boost::bind(&LLFloaterAvatarPicker::onList, _1, this));
+	nearme->setCommitCallback(boost::bind(&LLFloaterAvatarPicker::onList, this));

 	childSetAction("Select", boost::bind(&LLFloaterAvatarPicker::onBtnSelect, this));
 	getChildView("Select")->setEnabled(FALSE);
@@ -135,16 +129,17 @@ BOOL LLFloaterAvatarPicker::postBuild()
 		search_panel->setDefaultBtn("Find");
 	}

-	getChild<LLScrollListCtrl>("SearchResults")->addCommentText(getString("no_results"));
+	getChild<LLScrollListCtrl>("SearchResults")->setCommentText(getString("no_results"));

 	LLInventoryPanel* inventory_panel = getChild<LLInventoryPanel>("InventoryPanel");
 	inventory_panel->setFilterTypes(0x1 << LLInventoryType::IT_CALLINGCARD);
 	inventory_panel->setFollowsAll();
 	inventory_panel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
 	inventory_panel->openDefaultFolderForType(LLAssetType::AT_CALLINGCARD);
-	inventory_panel->setSelectCallback(boost::bind(&LLFloaterAvatarPicker::onCallingCardSelectionChange, _1, _2, (void*)this));
+	inventory_panel->setSelectCallback(boost::bind(&LLFloaterAvatarPicker::onCallingCardSelectionChange, this, _1, _2));

-	getChild<LLTabContainer>("ResidentChooserTabs")->setCommitCallback(boost::bind(&LLFloaterAvatarPicker::onTabChanged,this));
+	getChild<LLTabContainer>("ResidentChooserTabs")->setCommitCallback(
+		boost::bind(&LLFloaterAvatarPicker::onTabChanged,this));

 	setAllowMultiple(FALSE);

@@ -169,7 +164,7 @@ void LLFloaterAvatarPicker::onBtnFind()
 	find();
 }

-static void getSelectedAvatarData(const LLScrollListCtrl* from, std::vector<std::string>& avatar_names, std::vector<LLUUID>& avatar_ids)
+static void getSelectedAvatarData(const LLScrollListCtrl* from, uuid_vec_t& avatar_ids, std::vector<LLAvatarName>& avatar_names)
 {
 	std::vector<LLScrollListItem*> items = from->getAllSelected();
 	for (std::vector<LLScrollListItem*>::iterator iter = items.begin(); iter != items.end(); ++iter)
@@ -177,105 +172,141 @@ static void getSelectedAvatarData(const LLScrollListCtrl* from, std::vector<std:
 		LLScrollListItem* item = *iter;
 		if (item->getUUID().notNull())
 		{
-			avatar_names.push_back(item->getColumn(0)->getValue().asString());
 			avatar_ids.push_back(item->getUUID());
+
+			std::map<LLUUID, LLAvatarName>::iterator iter = sAvatarNameMap.find(item->getUUID());
+			if (iter != sAvatarNameMap.end())
+			{
+				avatar_names.push_back(iter->second);
+			}
+			else
+			{
+				// the only case where it isn't in the name map is friends
+				// but it should be in the name cache
+				LLAvatarName av_name;
+				LLAvatarNameCache::get(item->getUUID(), &av_name);
+				avatar_names.push_back(av_name);
+			}
 		}
 	}
 }

-void LLFloaterAvatarPicker::onBtnSelect(void* userdata)
+void LLFloaterAvatarPicker::onBtnSelect()
 {
-	LLFloaterAvatarPicker* self = (LLFloaterAvatarPicker*)userdata;

-	if(self->mCallback)
+	// If select btn not enabled then do not callback
+	if (!visibleItemsSelected())
+		return;
+
+	if(mSelectionCallback)
 	{
-		LLPanel* active_panel = self->childGetVisibleTab("ResidentChooserTabs");
-
-		if(active_panel == self->getChild<LLPanel>("CallingCardsPanel"))
+		std::vector<LLAvatarName>	avatar_names;
+		std::vector<LLUUID>			avatar_ids;
+		std::string active_panel_name;
+		LLScrollListCtrl* list =  NULL;
+		LLPanel* active_panel = childGetVisibleTab("ResidentChooserTabs");
+		if(active_panel)
 		{
-			self->mCallback(self->mSelectedInventoryAvatarNames, self->mSelectedInventoryAvatarIDs, self->mCallbackUserdata);
+			active_panel_name = active_panel->getName();
 		}
-		else if(active_panel == self->getChild<LLPanel>("SearchPanel"))
+		if(active_panel_name == "CallingCardsPanel")
 		{
-			std::vector<std::string>	avatar_names;
-			std::vector<LLUUID>			avatar_ids;
-			getSelectedAvatarData(self->getChild<LLScrollListCtrl>("SearchResults"), avatar_names, avatar_ids);
-			self->mCallback(avatar_names, avatar_ids, self->mCallbackUserdata);
+			avatar_ids = mSelectedInventoryAvatarIDs;
+			for(std::vector<std::string>::size_type i = 0; i < avatar_ids.size(); ++i)
+			{
+				std::map<LLUUID, LLAvatarName>::iterator iter = sAvatarNameMap.find(avatar_ids[i]);
+				LLAvatarName av_name;
+				if (iter != sAvatarNameMap.end())
+				{
+					avatar_names.push_back(iter->second);
+				}
+				else if(LLAvatarNameCache::get(avatar_ids[i], &av_name))
+				{
+					avatar_names.push_back(av_name);
+				}
+				else
+				{
+					std::string name = gCacheName->buildLegacyName(mSelectedInventoryAvatarNames[i]);
+					std::string::size_type pos = name.find(' ');
+					av_name.mLegacyFirstName = name.substr(pos);
+					av_name.mLegacyLastName = pos!=std::string::npos ? name.substr(pos+1) : "Resident";
+					av_name.mDisplayName = name;
+					av_name.mUsername = "";
+					avatar_names.push_back(av_name);
+				}
+			}
 		}
-		else if(active_panel == self->getChild<LLPanel>("NearMePanel"))
+		else if(active_panel_name == "SearchPanel")
 		{
-			std::vector<std::string>	avatar_names;
-			std::vector<LLUUID>			avatar_ids;
-			getSelectedAvatarData(self->getChild<LLScrollListCtrl>("NearMe"), avatar_names, avatar_ids);
-			self->mCallback(avatar_names, avatar_ids, self->mCallbackUserdata);
+			list = getChild<LLScrollListCtrl>("SearchResults");
 		}
-		else if(active_panel == self->getChild<LLPanel>("KeyPanel"))
+		else if(active_panel_name == "NearMePanel")
 		{
-			LLUUID specified = self->getChild<LLLineEditor>("EditUUID")->getValue().asUUID();
+			list = getChild<LLScrollListCtrl>("NearMe");
+		}
+		else if(active_panel_name == "KeyPanel")
+		{
+			LLUUID specified = getChild<LLLineEditor>("EditUUID")->getValue().asUUID();
 			if(specified.isNull())
 				return;
-			std::vector<std::string>	avatar_names;
-			std::vector<LLUUID>			avatar_ids;
 			avatar_ids.push_back(specified);
-			avatar_names.push_back(specified.asString());
-			self->mCallback(avatar_names, avatar_ids, self->mCallbackUserdata);
+
+			std::map<LLUUID, LLAvatarName>::iterator iter = sAvatarNameMap.find(specified);
+			if (iter != sAvatarNameMap.end())
+			{
+				avatar_names.push_back(iter->second);
+			}
+			else
+			{
+				LLAvatarName av_name;
+				LLAvatarNameCache::get(specified, &av_name);
+				avatar_names.push_back(av_name);
+			}
+		}
+
+		if(list)
+		{
+			getSelectedAvatarData(list, avatar_ids, avatar_names);
+		}
+		if(!avatar_names.empty() && !avatar_ids.empty())
+		{
+			mSelectionCallback(avatar_ids, avatar_names);
 		}
 	}
-	self->getChild<LLInventoryPanel>("InventoryPanel")->setSelection(LLUUID::null, FALSE);
-	self->getChild<LLScrollListCtrl>("SearchResults")->deselectAllItems(TRUE);
-	self->getChild<LLScrollListCtrl>("NearMe")->deselectAllItems(TRUE);
-	if(self->mCloseOnSelect)
+	getChild<LLInventoryPanel>("InventoryPanel")->setSelection(LLUUID::null, FALSE);
+	getChild<LLScrollListCtrl>("SearchResults")->deselectAllItems(TRUE);
+	getChild<LLScrollListCtrl>("NearMe")->deselectAllItems(TRUE);
+	if(mCloseOnSelect)
 	{
-		self->mCloseOnSelect = FALSE;
-		self->close();		
+		mCloseOnSelect = FALSE;
+		close();		
 	}
 }

-void LLFloaterAvatarPicker::onBtnRefresh(void* userdata)
+void LLFloaterAvatarPicker::onBtnRefresh()
 {
-	LLFloaterAvatarPicker* self = (LLFloaterAvatarPicker*)userdata;
-	if (!self)
-	{
-		return;
-	}
-	
-	self->getChild<LLScrollListCtrl>("NearMe")->deleteAllItems();
-	self->getChild<LLScrollListCtrl>("NearMe")->addCommentText(self->getString("searching"));
-	self->mNearMeListComplete = FALSE;
+	getChild<LLScrollListCtrl>("NearMe")->deleteAllItems();
+	getChild<LLScrollListCtrl>("NearMe")->setCommentText(getString("searching"));
+	mNearMeListComplete = FALSE;
 }

-void LLFloaterAvatarPicker::onBtnClose(void* userdata)
+void LLFloaterAvatarPicker::onBtnClose()
 {
-	LLFloaterAvatarPicker* self = (LLFloaterAvatarPicker*)userdata;
-	if(self) self->close();
+	close();
 }

-void LLFloaterAvatarPicker::onRangeAdjust(LLUICtrl* source, void* data)
+void LLFloaterAvatarPicker::onRangeAdjust()
 {
-	LLFloaterAvatarPicker::onBtnRefresh(data);
+	onBtnRefresh();
 }

-void LLFloaterAvatarPicker::onList(LLUICtrl* ctrl, void* userdata)
+void LLFloaterAvatarPicker::onList()
 {
-	LLFloaterAvatarPicker* self = (LLFloaterAvatarPicker*)userdata;
-	if (self)
-	{
-		self->childSetEnabled("Select", self->visibleItemsSelected());
-	}
-}
-
-// static callback for inventory picker (select from calling cards)
-void LLFloaterAvatarPicker::onCallingCardSelectionChange(const std::deque<LLFolderViewItem*> &items, BOOL user_action, void* data)
-{
-	LLFloaterAvatarPicker* self = (LLFloaterAvatarPicker*)data;
-	if (self)
-	{
-		self->doCallingCardSelectionChange( items, user_action, data );
-	}
+	getChildView("Select")->setEnabled(visibleItemsSelected());
 }

 // Callback for inventory picker (select from calling cards)
-void LLFloaterAvatarPicker::doCallingCardSelectionChange(const std::deque<LLFolderViewItem*> &items, BOOL user_action, void* data)
+void LLFloaterAvatarPicker::onCallingCardSelectionChange(const std::deque<LLFolderViewItem*> &items, BOOL user_action)
 {
 	bool panel_active = (childGetVisibleTab("ResidentChooserTabs") == getChild<LLPanel>("CallingCardsPanel"));
 	
@@ -315,7 +346,7 @@ void LLFloaterAvatarPicker::populateNearMe()
 	LLScrollListCtrl* near_me_scroller = getChild<LLScrollListCtrl>("NearMe");
 	near_me_scroller->deleteAllItems();

-	std::vector<LLUUID> avatar_ids;
+	uuid_vec_t avatar_ids;
 	LLWorld::getInstance()->getAvatars(&avatar_ids, NULL, gAgent.getPositionGlobal(), gSavedSettings.getF32("NearMeRange"));
 	for(U32 i=0; i<avatar_ids.size(); i++)
 	{
@@ -323,15 +354,22 @@ void LLFloaterAvatarPicker::populateNearMe()
 		if(av == gAgent.getID()) continue;
 		LLSD element;
 		element["id"] = av; // value
-		std::string fullname;
-		if(!gCacheName->getFullName(av, fullname))
+		LLAvatarName av_name;
+
+		if (!LLAvatarNameCache::get(av, &av_name))
 		{
+			element["columns"][0]["column"] = "name";
 			element["columns"][0]["value"] = LLCacheName::getDefaultName();
 			all_loaded = FALSE;
 		}			
 		else
 		{
-			element["columns"][0]["value"] = fullname;
+			element["columns"][0]["column"] = "name";
+			element["columns"][0]["value"] = av_name.mDisplayName;
+			element["columns"][1]["column"] = "username";
+			element["columns"][1]["value"] = av_name.mUsername;
+
+			sAvatarNameMap[av] = av_name;
 		}
 		near_me_scroller->addElement(element);
 		empty = FALSE;
@@ -339,16 +377,16 @@ void LLFloaterAvatarPicker::populateNearMe()

 	if (empty)
 	{
-		childDisable("NearMe");
-		childDisable("Select");
-		near_me_scroller->addCommentText(getString("no_one_near"));
+		getChildView("NearMe")->setEnabled(FALSE);
+		getChildView("Select")->setEnabled(FALSE);
+		near_me_scroller->setCommentText(getString("no_one_near"));
 	}
 	else 
 	{
-		childEnable("NearMe");
-		childEnable("Select");
+		getChildView("NearMe")->setEnabled(TRUE);
+		getChildView("Select")->setEnabled(TRUE);
 		near_me_scroller->selectFirstItem();
-		onList(near_me_scroller, this);
+		onList();
 		near_me_scroller->setFocus(TRUE);
 	}

@@ -401,38 +439,103 @@ BOOL LLFloaterAvatarPicker::visibleItemsSelected() const
 	}
 	else if(active_panel == getChild<LLPanel>("CallingCardsPanel"))
 	{
-		return mSelectedInventoryAvatarIDs.size() > 0;
+		return !mSelectedInventoryAvatarIDs.empty();
 	}
 	else if(active_panel == getChild<LLPanel>("NearMePanel"))
 	{
 		return getChild<LLScrollListCtrl>("NearMe")->getFirstSelectedIndex() >= 0;
 	}
+	else if(active_panel == getChild<LLPanel>("KeyPanel"))
+	{
+		LLUUID specified = getChild<LLLineEditor>("EditUUID")->getValue().asUUID();
+		return !specified.isNull();
+	}
 	return FALSE;
 }

+extern AIHTTPTimeoutPolicy avatarPickerResponder_timeout;
+class LLAvatarPickerResponder : public LLHTTPClient::ResponderWithCompleted
+{
+public:
+	LLUUID mQueryID;
+
+	LLAvatarPickerResponder(const LLUUID& id) : mQueryID(id) { }
+	
+	/*virtual*/ void completed(U32 status, const std::string& reason, const LLSD& content)
+	{
+		//std::ostringstream ss;
+		//LLSDSerialize::toPrettyXML(content, ss);
+		//llinfos << ss.str() << llendl;
+
+		// in case of invalid characters, the avatar picker returns a 400
+		// just set it to process so it displays 'not found'
+		if ((200 <= status && status < 300) || status == 400)
+		{
+			LLFloaterAvatarPicker* floater = LLFloaterAvatarPicker::sInstance;
+			if (floater)
+			{
+				floater->processResponse(mQueryID, content);
+			}
+		}
+		else
+		{
+			llinfos << "avatar picker failed " << status
+					<< " reason " << reason << llendl;
+			
+		}
+	}
+
+	const AIHTTPTimeoutPolicy &getHTTPTimeoutPolicy(void) const { return avatarPickerResponder_timeout; }
+};
+
 void LLFloaterAvatarPicker::find()
 {
+	//clear our stored LLAvatarNames
+	sAvatarNameMap.clear();
+
 	const std::string& text = childGetValue("Edit").asString();

 	mQueryID.generate();

-	LLMessageSystem* msg = gMessageSystem;
+	std::string url;
+	url.reserve(128); // avoid a memory allocation or two

-	msg->newMessage("AvatarPickerRequest");
-	msg->nextBlock("AgentData");
-	msg->addUUID("AgentID", gAgent.getID());
-	msg->addUUID("SessionID", gAgent.getSessionID());
-	msg->addUUID("QueryID", mQueryID);	// not used right now
-	msg->nextBlock("Data");
-	msg->addString("Name", text);
-
-	gAgent.sendReliableMessage();
+	LLViewerRegion* region = gAgent.getRegion();
+	url = region->getCapability("AvatarPickerSearch");
+	// Prefer use of capabilities to search on both SLID and display name
+	// but allow display name search to be manually turned off for test
+	if (!url.empty()
+		&& LLAvatarNameCache::useDisplayNames())
+	{
+		// capability urls don't end in '/', but we need one to parse
+		// query parameters correctly
+		if (url.size() > 0 && url[url.size()-1] != '/')
+		{
+			url += "/";
+		}
+		url += "?page_size=100&names=";
+		url += LLURI::escape(text);
+		llinfos << "avatar picker " << url << llendl;
+		LLHTTPClient::get(url, new LLAvatarPickerResponder(mQueryID));
+	}
+	else
+	{
+		LLMessageSystem* msg = gMessageSystem;
+		msg->newMessage("AvatarPickerRequest");
+		msg->nextBlock("AgentData");
+		msg->addUUID("AgentID", gAgent.getID());
+		msg->addUUID("SessionID", gAgent.getSessionID());
+		msg->addUUID("QueryID", mQueryID);	// not used right now
+		msg->nextBlock("Data");
+		msg->addString("Name", text);
+		gAgent.sendReliableMessage();
+	}

 	getChild<LLScrollListCtrl>("SearchResults")->deleteAllItems();
-	getChild<LLScrollListCtrl>("SearchResults")->addCommentText(getString("searching"));
+	getChild<LLScrollListCtrl>("SearchResults")->setCommentText(getString("searching"));
 	
 	childSetEnabled("Select", FALSE);
-	mResultsReturned = FALSE;
+	mNumResultsReturned = 0;
 }

 void LLFloaterAvatarPicker::setAllowMultiple(BOOL allow_multiple)
@@ -458,21 +561,21 @@ void LLFloaterAvatarPicker::processAvatarPickerReply(LLMessageSystem* msg, void*
 	if (agent_id != gAgent.getID()) return;

 	// Dialog already closed
-	LLFloaterAvatarPicker *self = sInstance;
-	if (!self) return;
+	LLFloaterAvatarPicker *floater = sInstance;

-	// these are not results from our last request
-	if (query_id != self->mQueryID)
+	// floater is closed or these are not results from our last request
+	if (NULL == floater || query_id != floater->mQueryID)
 	{
 		return;
 	}

-	LLScrollListCtrl* search_results = self->getChild<LLScrollListCtrl>("SearchResults");
+	LLScrollListCtrl* search_results = floater->getChild<LLScrollListCtrl>("SearchResults");

 	// clear "Searching" label on first results
-	search_results->deleteAllItems();
-
-	self->mResultsReturned = TRUE;
+	if (floater->mNumResultsReturned++ == 0)
+	{
+		search_results->deleteAllItems();
+	}

 	BOOL found_one = FALSE;
 	S32 num_new_rows = msg->getNumberOfBlocks("Data");
@@ -486,16 +589,24 @@ void LLFloaterAvatarPicker::processAvatarPickerReply(LLMessageSystem* msg, void*
 		if (avatar_id.isNull())
 		{
 			LLStringUtil::format_map_t map;
-			map["[TEXT]"] = self->childGetText("Edit");
-			avatar_name = self->getString("not_found", map);
+			map["[TEXT]"] = floater->childGetText("Edit");
+			avatar_name = floater->getString("not_found", map);
 			search_results->setEnabled(FALSE);
-			self->childDisable("Select");
+			floater->getChildView("Select")->setEnabled(FALSE);
 		}
 		else
 		{
-			avatar_name = first_name + " " + last_name;
+			avatar_name = LLCacheName::buildFullName(first_name, last_name);
 			search_results->setEnabled(TRUE);
 			found_one = TRUE;
+
+			LLAvatarName av_name;
+			av_name.mLegacyFirstName = first_name;
+			av_name.mLegacyLastName = last_name;
+			av_name.mDisplayName = avatar_name;
+			const LLUUID& agent_id = avatar_id;
+			sAvatarNameMap[agent_id] = av_name;
+
 		}
 		LLSD element;
 		element["id"] = avatar_id; // value
@@ -506,13 +617,64 @@ void LLFloaterAvatarPicker::processAvatarPickerReply(LLMessageSystem* msg, void*

 	if (found_one)
 	{
-		self->childEnable("Select");
+		floater->getChildView("Select")->setEnabled(TRUE);
 		search_results->selectFirstItem();
-		self->onList(search_results, self);
+		floater->onList();
 		search_results->setFocus(TRUE);
 	}
 }

+void LLFloaterAvatarPicker::processResponse(const LLUUID& query_id, const LLSD& content)
+{
+	// Check for out-of-date query
+	if (query_id != mQueryID) return;
+
+	LLScrollListCtrl* search_results = getChild<LLScrollListCtrl>("SearchResults");
+
+	LLSD agents = content["agents"];
+	if (agents.size() == 0)
+	{
+		LLStringUtil::format_map_t map;
+		map["[TEXT]"] = childGetText("Edit");
+		LLSD item;
+		item["id"] = LLUUID::null;
+		item["columns"][0]["column"] = "name";
+		item["columns"][0]["value"] = getString("not_found", map);
+		search_results->addElement(item);
+		search_results->setEnabled(false);
+		getChildView("Select")->setEnabled(false);
+		return;
+	}
+
+	// clear "Searching" label on first results
+	search_results->deleteAllItems();
+
+	LLSD item;
+	LLSD::array_const_iterator it = agents.beginArray();
+	for ( ; it != agents.endArray(); ++it)
+	{
+		const LLSD& row = *it;
+		item["id"] = row["id"];
+		LLSD& columns = item["columns"];
+		columns[0]["column"] = "name";
+		columns[0]["value"] = row["display_name"];
+		columns[1]["column"] = "username";
+		columns[1]["value"] = row["username"];
+		search_results->addElement(item);
+
+		// add the avatar name to our list
+		LLAvatarName avatar_name;
+		avatar_name.fromLLSD(row);
+		sAvatarNameMap[row["id"].asUUID()] = avatar_name;
+	}
+
+	getChildView("Select")->setEnabled(true);
+	search_results->setEnabled(true);
+	search_results->selectFirstItem();
+	onList();
+	search_results->setFocus(TRUE);
+}
+
 //static
 void LLFloaterAvatarPicker::editKeystroke(LLLineEditor* caller, void* user_data)
 {
@@ -532,13 +694,13 @@ BOOL LLFloaterAvatarPicker::handleKeyHere(KEY key, MASK mask)
 {
 	if (key == KEY_RETURN && mask == MASK_NONE)
 	{
-		if (childHasFocus("Edit"))
+		if (getChild<LLUICtrl>("Edit")->hasFocus())
 		{
-			onBtnFind(this);
+			onBtnFind();
 		}
 		else
 		{
-			onBtnSelect(this);
+			onBtnSelect();
 		}
 		return TRUE;
 	}