/** 
 * @file llinspectavatar.cpp
 *
 * $LicenseInfo:firstyear=2009&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

#include "llinspectavatar.h"

// viewer files
#include "llagent.h"
#include "llavataractions.h"
#include "llavatariconctrl.h"
#include "llavatarnamecache.h"
#include "llavatarpropertiesprocessor.h"
#include "lldateutil.h"
// [SL:KB] - World-Mute | Checked: 2013-12-12 (Catznip-3.6)
#include "llfloaterblocked.h"
// [/SL:KB]
#include "llinspect.h"
#include "llmutelist.h"
#include "llslurl.h"
#include "llstartup.h"
#include "llvoiceclient.h"
#include "lltransientfloatermgr.h"

// Linden libraries
#include "llfloater.h"
#include "llfloaterreg.h"
#include "lltextbox.h"
#include "lltooltip.h"	// positionViewNearMouse()
#include "lltrans.h"

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
#include "llfloaterreporter.h"
#include "llfloaterworldmap.h"
#include "llmenubutton.h"
#include "llnotificationsutil.h"
#include "llpanelblockedlist.h"
#include "lltoggleablemenu.h"
#include "llviewerobjectlist.h"
// [/SL:KB]

class LLFetchAvatarData;


//////////////////////////////////////////////////////////////////////////////
// LLInspectAvatar
//////////////////////////////////////////////////////////////////////////////

// Avatar Inspector, a small information window used when clicking
// on avatar names in the 2D UI and in the ambient inspector widget for
// the 3D world.
class LLInspectAvatar : public LLInspect, LLTransientFloater
{
	friend class LLFloaterReg;
	
public:
	// avatar_id - Avatar ID for which to show information
	// Inspector will be positioned relative to current mouse position
	LLInspectAvatar(const LLSD& avatar_id);
	virtual ~LLInspectAvatar();

	/*virtual*/ BOOL postBuild(void);
	
	// Because floater is single instance, need to re-parse data on each spawn
	// (for example, inspector about same avatar but in different position)
	/*virtual*/ void onOpen(const LLSD& avatar_id);

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	// When closing they should close their gear menu 
	/*virtual*/ void onClose(bool app_quitting);

	// override the inspector mouse leave so timer is only paused if gear menu is not open
	/*virtual*/ void onMouseLeave(S32 x, S32 y, MASK mask);
// [/SL:KB]

	// Update view based on information from avatar properties processor
	void processAvatarData(LLAvatarData* data);
	
	virtual LLTransientFloaterMgr::ETransientGroup getGroup() { return LLTransientFloaterMgr::GLOBAL; }

private:
	// Make network requests for all the data to display in this view.
	// Used on construction and if avatar id changes.
	void requestUpdate();

	// Set the volume slider to this user's current client-side volume setting,
	// hiding/disabling if the user is not nearby.
	void updateVolumeSlider();

	// Button callbacks
// [SL:KB] - Patch: Agent-DisplayNames | Checked: 2011-11-10 (Catznip-3.2)
	void onClickCopy(const LLSD& sdParam);
// [/SL:KB]
	void onClickMuteVolume();
	void onVolumeChange(const LLSD& data);
// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	// Button callbacks
	void onAvatarAction(const LLSD& sdParam);
	bool onAvatarEnableAction(const LLSD& sdParam) const;
// [/SL:KB]
	
	void onAvatarNameCache(const LLUUID& agent_id,
						   const LLAvatarName& av_name);
	
private:
	LLUUID				mAvatarID;
	// Need avatar name information to spawn friend add request
	LLAvatarName		mAvatarName;
// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	S32					mDescriptionHeight;
	S32					mDescriptionHeightExpanded;
// [/SL:KB]
	// an in-flight request for avatar properties from LLAvatarPropertiesProcessor
	// is represented by this object
	LLFetchAvatarData*	mPropertiesRequest;
	boost::signals2::connection mAvatarNameCacheConnection;
};

//////////////////////////////////////////////////////////////////////////////
// LLFetchAvatarData
//////////////////////////////////////////////////////////////////////////////

// This object represents a pending request for avatar properties information
class LLFetchAvatarData : public LLAvatarPropertiesObserver
{
public:
	// If the inspector closes it will delete the pending request object, so the
	// inspector pointer will be valid for the lifetime of this object
	LLFetchAvatarData(const LLUUID& avatar_id, LLInspectAvatar* inspector)
	:	mAvatarID(avatar_id),
		mInspector(inspector)
	{
		LLAvatarPropertiesProcessor* processor = 
			LLAvatarPropertiesProcessor::getInstance();
		// register ourselves as an observer
		processor->addObserver(mAvatarID, this);
		// send a request (duplicates will be suppressed inside the avatar
		// properties processor)
		processor->sendAvatarPropertiesRequest(mAvatarID);
	}
	
	~LLFetchAvatarData()
	{
		// remove ourselves as an observer
		LLAvatarPropertiesProcessor::getInstance()->
		removeObserver(mAvatarID, this);
	}
	
	void processProperties(void* data, EAvatarProcessorType type)
	{
		// route the data to the inspector
		if (data
			&& type == APT_PROPERTIES)
		{
			LLAvatarData* avatar_data = static_cast<LLAvatarData*>(data);
			mInspector->processAvatarData(avatar_data);
		}
	}
	
	// Store avatar ID so we can un-register the observer on destruction
	LLUUID mAvatarID;
	LLInspectAvatar* mInspector;
};

LLInspectAvatar::LLInspectAvatar(const LLSD& sd)
:	LLInspect( LLSD() ),	// single_instance, doesn't really need key
	mAvatarID(),			// set in onOpen()  *Note: we used to show partner's name but we dont anymore --angela 3rd Dec* 
	mAvatarName(),
// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	mDescriptionHeight(-1),
	mDescriptionHeightExpanded(-1),
// [/SL:KB]
	mPropertiesRequest(NULL),
	mAvatarNameCacheConnection()
{
// [SL:KB] - Patch: Agent-DisplayNames | Checked: 2011-11-10 (Catznip-3.2)
	mCommitCallbackRegistrar.add("InspectAvatar.Copy", boost::bind(&LLInspectAvatar::onClickCopy, this, _2));
// [/SL:KB]
// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	mCommitCallbackRegistrar.add("InspectAvatar.Action",      boost::bind(&LLInspectAvatar::onAvatarAction, this, _2));	
	mEnableCallbackRegistrar.add("InspectAvatar.CheckAction", boost::bind(&LLInspectAvatar::onAvatarEnableAction, this, _2));
// [/SL:KB]

	// can't make the properties request until the widgets are constructed
	// as it might return immediately, so do it in onOpen.

	LLTransientFloaterMgr::getInstance()->addControlView(LLTransientFloaterMgr::GLOBAL, this);
	LLTransientFloater::init(this);
}

LLInspectAvatar::~LLInspectAvatar()
{
	if (mAvatarNameCacheConnection.connected())
	{
		mAvatarNameCacheConnection.disconnect();
	}
	// clean up any pending requests so they don't call back into a deleted
	// view
	delete mPropertiesRequest;
	mPropertiesRequest = NULL;

	LLTransientFloaterMgr::getInstance()->removeControlView(this);
}

/*virtual*/
BOOL LLInspectAvatar::postBuild(void)
{
// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	const LLRect rctDescription = getChild<LLUICtrl>("user_details")->getRect();
	const LLRect rctVolume = getChild<LLUICtrl>("volume_slider")->getRect();
	mDescriptionHeight = rctDescription.getHeight();
	mDescriptionHeightExpanded = mDescriptionHeight + (rctDescription.mBottom - rctVolume.mBottom);

	getChild<LLUICtrl>("view_profile_btn")->setCommitCallback(boost::bind(&LLInspectAvatar::onAvatarAction, this, "profile"));
	getChild<LLUICtrl>("add_friend_btn")->setCommitCallback(boost::bind(&LLInspectAvatar::onAvatarAction, this, "friend_add"));
	getChild<LLUICtrl>("im_btn")->setCommitCallback(boost::bind(&LLInspectAvatar::onAvatarAction, this, "send_im"));
// [/SL:KB]

	getChild<LLUICtrl>("mute_btn")->setCommitCallback(
		boost::bind(&LLInspectAvatar::onClickMuteVolume, this) );

	getChild<LLUICtrl>("volume_slider")->setCommitCallback(
		boost::bind(&LLInspectAvatar::onVolumeChange, this, _2));

	return TRUE;
}

// Multiple calls to showInstance("inspect_avatar", foo) will provide different
// LLSD for foo, which we will catch here.
//virtual
void LLInspectAvatar::onOpen(const LLSD& data)
{
	// Start open animation
	LLInspect::onOpen(data);

	// Extract appropriate avatar id
	mAvatarID = data["avatar_id"];

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	bool fIsSelf = (gAgent.getID() == mAvatarID);
	getChild<LLUICtrl>("gear_self_btn")->setVisible(fIsSelf);
	getChild<LLUICtrl>("gear_btn")->setVisible(!fIsSelf);
// [/SL:KB]

	// Position the inspector relative to the mouse cursor
	// Similar to how tooltips are positioned
	// See LLToolTipMgr::createToolTip
	if (data.has("pos"))
	{
		LLUI::positionViewNearMouse(this, data["pos"]["x"].asInteger(), data["pos"]["y"].asInteger());
	}
	else
	{
		LLUI::positionViewNearMouse(this);
	}

//	// Generate link to avatar profile.
//	LLTextBase* avatar_profile_link = getChild<LLTextBase>("avatar_profile_link");
//	avatar_profile_link->setTextArg("[LINK]", LLSLURL("agent", mAvatarID, "about").getSLURLString());
//	avatar_profile_link->setIsFriendCallback(LLAvatarActions::isFriend);

	// can't call from constructor as widgets are not built yet
	requestUpdate();

	updateVolumeSlider();
}

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
// virtual
void LLInspectAvatar::onClose(bool app_quitting)
{  
	getChild<LLMenuButton>("gear_self_btn")->hideMenu();
	getChild<LLMenuButton>("gear_btn")->hideMenu();
}	
// [/SL:KB]

void LLInspectAvatar::requestUpdate()
{
	// Don't make network requests when spawning from the debug menu at the
	// login screen (which is useful to work on the layout).
	if (mAvatarID.isNull())
	{
		if (LLStartUp::getStartupState() >= STATE_STARTED)
		{
			// once we're running we don't want to show the test floater
			// for bogus LLUUID::null links
			closeFloater();
		}
		return;
	}

	// Clear out old data so it doesn't flash between old and new
	getChild<LLUICtrl>("user_name")->setValue("");
	getChild<LLUICtrl>("user_name_small")->setValue("");
	getChild<LLUICtrl>("user_slid")->setValue("");
	getChild<LLUICtrl>("user_subtitle")->setValue("");
	getChild<LLUICtrl>("user_details")->setValue("");
	
	// Make a new request for properties
	delete mPropertiesRequest;
	mPropertiesRequest = new LLFetchAvatarData(mAvatarID, this);

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
	// You can't re-add someone as a friend if they are already your friend
	bool is_friend = LLAvatarTracker::instance().getBuddyInfo(mAvatarID) != NULL;
	bool is_self = (mAvatarID == gAgentID);
	if (is_self)
	{
		getChild<LLUICtrl>("add_friend_btn")->setVisible(false);
		getChild<LLUICtrl>("im_btn")->setVisible(false);
	}
	else if (is_friend)
	{
		getChild<LLUICtrl>("add_friend_btn")->setVisible(false);
		getChild<LLUICtrl>("im_btn")->setVisible(true);
	}
	else
	{
		getChild<LLUICtrl>("add_friend_btn")->setVisible(true);
		getChild<LLUICtrl>("im_btn")->setVisible(false);
	}
// [/SL:KB]

	// Use an avatar_icon even though the image id will come down with the
	// avatar properties because the avatar_icon code maintains a cache of icons
	// and this may result in the image being visible sooner.
	// *NOTE: This may generate a duplicate avatar properties request, but that
	// will be suppressed internally in the avatar properties processor.
	
	//remove avatar id from cache to get fresh info
	LLAvatarIconIDCache::getInstance()->remove(mAvatarID);

	getChild<LLUICtrl>("avatar_icon")->setValue(LLSD(mAvatarID) );

	if (mAvatarNameCacheConnection.connected())
	{
		mAvatarNameCacheConnection.disconnect();
	}
	mAvatarNameCacheConnection = LLAvatarNameCache::get(mAvatarID,boost::bind(&LLInspectAvatar::onAvatarNameCache,this, _1, _2));
}

void LLInspectAvatar::processAvatarData(LLAvatarData* data)
{
	LLStringUtil::format_map_t args;
	{
		std::string birth_date = LLTrans::getString("AvatarBirthDateFormat");
		LLStringUtil::format(birth_date, LLSD().with("datetime", (S32) data->born_on.secondsSinceEpoch()));
		args["[BORN_ON]"] = birth_date;
	}
	args["[AGE]"] = LLDateUtil::ageFromDate(data->born_on, LLDate::now());
	args["[SL_PROFILE]"] = data->about_text;
	args["[RW_PROFILE"] = data->fl_about_text;
	args["[ACCTTYPE]"] = LLAvatarPropertiesProcessor::accountType(data);
	std::string payment_info = LLAvatarPropertiesProcessor::paymentInfo(data);
	args["[PAYMENTINFO]"] = payment_info;
	args["[COMMA]"] = (payment_info.empty() ? "" : ",");

	std::string subtitle = getString("Subtitle", args);
	getChild<LLUICtrl>("user_subtitle")->setValue( LLSD(subtitle) );
	std::string details = getString("Details", args);
	getChild<LLUICtrl>("user_details")->setValue( LLSD(details) );

	// Delete the request object as it has been satisfied
	delete mPropertiesRequest;
	mPropertiesRequest = NULL;
}

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
// For the avatar inspector, we only want to unpause the fade timer 
// if neither the gear menu or self gear menu are open
void LLInspectAvatar::onMouseLeave(S32 x, S32 y, MASK mask)
{
	LLToggleableMenu* gear_menu = getChild<LLMenuButton>("gear_btn")->getMenu();
	LLToggleableMenu* gear_menu_self = getChild<LLMenuButton>("gear_self_btn")->getMenu();

	if ( (gear_menu) && (gear_menu->getVisible()) || (gear_menu_self) && (gear_menu_self->getVisible()) )
	{
		return;
	}

	if (childHasVisiblePopupMenu())
	{
		return;
	}

	mOpenTimer.unpause();
}
// [/SL:KB]

void LLInspectAvatar::updateVolumeSlider()
{
	bool voice_enabled = LLVoiceClient::getInstance()->getVoiceEnabled(mAvatarID);

	// Do not display volume slider and mute button if it 
	// is ourself or we are not in a voice channel together
	if (!voice_enabled || (mAvatarID == gAgent.getID()))
	{
		getChild<LLUICtrl>("mute_btn")->setVisible(false);
		getChild<LLUICtrl>("volume_slider")->setVisible(false);

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
		// TODO-Catznip: find a better way?
		LLUICtrl* pDescription = getChild<LLUICtrl>("user_details");
		const LLRect rctDescription = pDescription->getRect();
		pDescription->reshape(rctDescription.getWidth(), mDescriptionHeightExpanded);
		pDescription->translate(0, rctDescription.getHeight() - mDescriptionHeightExpanded);
// [/SL:KB]
	}

	else 
	{
		getChild<LLUICtrl>("mute_btn")->setVisible(true);
		getChild<LLUICtrl>("volume_slider")->setVisible(true);

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
		// TODO-Catznip: find a better way?
		LLUICtrl* pDescription = getChild<LLUICtrl>("user_details");
		const LLRect rctDescription = pDescription->getRect();
		pDescription->reshape(rctDescription.getWidth(), mDescriptionHeight);
		pDescription->translate(0, rctDescription.getHeight() - mDescriptionHeight);
// [/SL:KB]

		// By convention, we only display and toggle voice mutes, not all mutes
		bool is_muted = LLAvatarActions::isVoiceMuted(mAvatarID);

		LLUICtrl* mute_btn = getChild<LLUICtrl>("mute_btn");

		bool is_linden = LLStringUtil::endsWith(mAvatarName.getDisplayName(), " Linden");

		mute_btn->setEnabled( !is_linden);
		mute_btn->setValue( is_muted );

		LLUICtrl* volume_slider = getChild<LLUICtrl>("volume_slider");
		volume_slider->setEnabled( !is_muted );

		F32 volume;
		
		if (is_muted)
		{
			// it's clearer to display their volume as zero
			volume = 0.f;
		}
		else
		{
			// actual volume
			volume = LLVoiceClient::getInstance()->getUserVolume(mAvatarID);
		}
		volume_slider->setValue( (F64)volume );
	}

}

void LLInspectAvatar::onClickMuteVolume()
{
	// By convention, we only display and toggle voice mutes, not all mutes
	LLMuteList* mute_list = LLMuteList::getInstance();
	bool is_muted = mute_list->isMuted(mAvatarID, LLMute::flagVoiceChat);

	LLMute mute(mAvatarID, mAvatarName.getDisplayName(), LLMute::AGENT);
	if (!is_muted)
	{
		mute_list->add(mute, LLMute::flagVoiceChat);
	}
	else
	{
		mute_list->remove(mute, LLMute::flagVoiceChat);
	}

	updateVolumeSlider();
}

void LLInspectAvatar::onVolumeChange(const LLSD& data)
{
	F32 volume = (F32)data.asReal();
	LLVoiceClient::getInstance()->setUserVolume(mAvatarID, volume);
}

void LLInspectAvatar::onAvatarNameCache(
		const LLUUID& agent_id,
		const LLAvatarName& av_name)
{
	mAvatarNameCacheConnection.disconnect();

	if (agent_id == mAvatarID)
	{
		getChild<LLUICtrl>("user_name")->setValue(av_name.getDisplayName());
		getChild<LLUICtrl>("user_name_small")->setValue(av_name.getDisplayName());
// [SL:KB] - Patch: Agent-DisplayNames | Checked: 2013-08-03 (Catznip-3.6)
		getChild<LLUICtrl>("user_slid")->setValue(av_name.getAccountName());
// [/SL:KB]
//		getChild<LLUICtrl>("user_slid")->setValue(av_name.getUserName());
		mAvatarName = av_name;
		
		// show smaller display name if too long to display in regular size
		if (getChild<LLTextBox>("user_name")->getTextPixelWidth() > getChild<LLTextBox>("user_name")->getRect().getWidth())
		{
			getChild<LLUICtrl>("user_name_small")->setVisible( true );
			getChild<LLUICtrl>("user_name")->setVisible( false );
		}
		else
		{
			getChild<LLUICtrl>("user_name_small")->setVisible( false );
			getChild<LLUICtrl>("user_name")->setVisible( true );

		}

	}
}

// [SL:KB] - Patch: Agent-DisplayNames | Checked: 2011-11-10 (Catznip-3.2)
void LLInspectAvatar::onClickCopy(const LLSD& sdParam)
{
	LLAvatarActions::copyToClipboard(mAvatarID, sdParam);
	closeFloater();
}
// [/SL:KB]

// [SL:KB] - Patch: Control-AvatarInspector | Checked: 2013-05-03 (Catznip-3.5)
void LLInspectAvatar::onAvatarAction(const LLSD& sdParam)
{
	const std::string strAction = sdParam.asString();

	if ("profile" == strAction)
	{
		LLAvatarActions::showProfile(mAvatarID);
	}
	else if ("friend_add" == strAction)
	{
		LLAvatarActions::requestFriendshipDialog(mAvatarID, mAvatarName.getCompleteName());
	}
	else if ("send_im" == strAction)
	{
		LLAvatarActions::startIM(mAvatarID);
	}
	else if ("call" == strAction)
	{
		LLAvatarActions::startCall(mAvatarID);
	}
	else if ("teleport" == strAction)
	{
		LLAvatarActions::offerTeleport(mAvatarID);
	}
	else if ("invite_group" == strAction)
	{
		LLAvatarActions::inviteToGroup(mAvatarID);
	}
	else if ("pay" == strAction)
	{
		LLAvatarActions::pay(mAvatarID);
	}
	else if ("share" == strAction)
	{
		LLAvatarActions::share(mAvatarID);
	}
	else if ("toggle_mute" == strAction)
	{
		LLAvatarActions::toggleBlock(mAvatarID);
// [SL:KB] - World-Mute | Checked: 2013-07-10 (Catznip-3.5)
		LLFloaterBlocked::showMuteAndSelect(mAvatarID);
// [/SL:KB]
//		LLPanelBlockedList::showPanelAndSelect(mAvatarID);
	}
	else if ("freeze" == strAction)
	{
		handle_avatar_freeze(LLSD(mAvatarID));
	}
	else if ("eject" == strAction)
	{
		handle_avatar_eject( LLSD(mAvatarID) );
	}
	else if ("report" == strAction)
	{
		LLFloaterReporter::showFromAvatar(mAvatarID, mAvatarName.getCompleteName());
	}
	else if ("find_map" == strAction)
	{
		gFloaterWorldMap->trackAvatar(mAvatarID, mAvatarName.getDisplayName());
		LLFloaterReg::showInstance("world_map");
	}
	else if ("zoom_in" == strAction)
	{
		handle_zoom_to_object(mAvatarID);
	}

	closeFloater();
}

bool LLInspectAvatar::onAvatarEnableAction(const LLSD& sdParam) const
{
	const std::string strAction = sdParam.asString();

	if ("friend_add" == strAction)
	{
		return !LLAvatarActions::isFriend(mAvatarID);
	}
	else if ("teleport" == strAction)
	{
		return LLAvatarActions::canOfferTeleport(mAvatarID);
	}
	else if ("check_mute" == strAction)
	{
		return (!LLAvatarActions::isBlocked(mAvatarID)) && (LLAvatarActions::canBlock(mAvatarID));
	}
	else if ("check_unmute" == strAction)
	{
		return LLAvatarActions::isBlocked(mAvatarID);
	}
	else if ("freeze" == strAction)
	{
		return enable_freeze_eject(LLSD(mAvatarID));
	}
	else if ("eject" == strAction)
	{
		return enable_freeze_eject(LLSD(mAvatarID));
	}
	else if ("find_map" == strAction)
	{
		return is_agent_mappable(mAvatarID);
	}
	else if ("zoom_in" == strAction)
	{
		return gObjectList.findObject(mAvatarID);
	}
	return false;
}
// [/SL:KB]

//////////////////////////////////////////////////////////////////////////////
// LLInspectAvatarUtil
//////////////////////////////////////////////////////////////////////////////
void LLInspectAvatarUtil::registerFloater()
{
	LLFloaterReg::add("inspect_avatar", "inspect_avatar.xml",
					  &LLFloaterReg::build<LLInspectAvatar>);
}
