phoenix-firestorm/indra/newview/llinspectavatar.cpp

/**
 * @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"
#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 "lltrans.h"

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);

    // 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
    void onClickMuteVolume();
    void onVolumeChange(const LLSD& data);

    void onAvatarNameCache(const LLUUID& agent_id,
                           const LLAvatarName& av_name);

private:
    LLUUID              mAvatarID;
    // Need avatar name information to spawn friend add request
    LLAvatarName        mAvatarName;
    // 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(),
    mPropertiesRequest(NULL),
    mAvatarNameCacheConnection()
{
    // 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)
{
    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"];

    LLInspect::repositionInspector(data);

    // 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();
}

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);

    // 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(data->hide_age ?
        "AvatarBirthDateFormatShort" :
        "AvatarBirthDateFormatFull");
        LLStringUtil::format(birth_date, LLSD().with("datetime", (S32) data->born_on.secondsSinceEpoch()));
        args["[BORN_ON]"] = birth_date;
    args["[AGE]"] = data->hide_age ?
        LLStringUtilBase<char>::null :
        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;
}

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);
    }

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

        // 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.getUserName(), 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());
        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 );

        }

    }
}

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