cbfa47c0da
Minor updates to code, mostly just a migration with some v3 stuff commented, since we don't have LLAvatarList and must use buttons since scrolllist menus don't actually exist nicely yet. Added toggleMuteVoice and isVoiceMuted to LLAvatarActions Added a minor touch to the voice volume slider, it'll now offer changing your own volume while in an active voice session.. nice to not drop out of an import voice session just to fix yourself. Also, fix a bug with SpeakerMgr's not flagging speakers for removal properly, causing external speakers and speakers managed by LLActiveSpeakerMgr to never actually get removed.
761 lines
20 KiB
C++
761 lines
20 KiB
C++
/**
|
|
* @file llavataractions.cpp
|
|
* @brief Friend-related actions (add, remove, offer teleport, etc)
|
|
*
|
|
* $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 "llavataractions.h"
|
|
|
|
#include "llavatarnamecache.h" // IDEVO
|
|
#include "llnotificationsutil.h" // for LLNotificationsUtil
|
|
#include "roles_constants.h" // for GP_MEMBER_INVITE
|
|
|
|
#include "llagent.h"
|
|
#include "llcallingcard.h" // LLAvatarTracker
|
|
#include "llfloateravatarinfo.h"
|
|
#include "llfloatergroupinvite.h"
|
|
#include "llfloatergroups.h"
|
|
#include "llfloaterworldmap.h"
|
|
#include "llgivemoney.h"
|
|
#include "llimview.h" // for gIMMgr
|
|
#include "llinventoryobserver.h"
|
|
#include "llmutelist.h"
|
|
#include "lltrans.h"
|
|
#include "llvoiceclient.h"
|
|
#include "llweb.h"
|
|
// [RLVa:KB] - Checked: 2011-04-11 (RLVa-1.3.0h) | Added: RLVa-1.3.0h
|
|
#include "rlvhandler.h"
|
|
// [/RLVa:KB]
|
|
|
|
extern const S32 TRANS_GIFT;
|
|
void give_money(const LLUUID& uuid, LLViewerRegion* region, S32 amount, BOOL is_group = FALSE, S32 trx_type = TRANS_GIFT, const std::string& desc = LLStringUtil::null);
|
|
void handle_lure(const uuid_vec_t& ids);
|
|
void send_improved_im(const LLUUID& to_id, const std::string& name, const std::string& message, U8 offline, EInstantMessage dialog, const LLUUID& id, U32 timestamp = NO_TIMESTAMP, const U8* binary_bucket = (U8*)EMPTY_BINARY_BUCKET, S32 binary_bucket_size = EMPTY_BINARY_BUCKET_SIZE);
|
|
|
|
// static
|
|
void LLAvatarActions::requestFriendshipDialog(const LLUUID& id, const std::string& name)
|
|
{
|
|
if(id == gAgentID)
|
|
{
|
|
LLNotificationsUtil::add("AddSelfFriend");
|
|
return;
|
|
}
|
|
|
|
LLSD args;
|
|
args["NAME"] = name;
|
|
LLSD payload;
|
|
payload["id"] = id;
|
|
payload["name"] = name;
|
|
|
|
LLNotificationsUtil::add("AddFriendWithMessage", args, payload, &callbackAddFriendWithMessage);
|
|
}
|
|
|
|
void on_avatar_name_friendship(const LLUUID& id, const LLAvatarName av_name)
|
|
{
|
|
LLAvatarActions::requestFriendshipDialog(id, av_name.getCompleteName());
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::requestFriendshipDialog(const LLUUID& id)
|
|
{
|
|
if(id.isNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_friendship, _1, _2));
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::removeFriendDialog(const LLUUID& id)
|
|
{
|
|
if (id.isNull())
|
|
return;
|
|
|
|
uuid_vec_t ids;
|
|
ids.push_back(id);
|
|
removeFriendsDialog(ids);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::removeFriendsDialog(const uuid_vec_t& ids)
|
|
{
|
|
if(ids.size() == 0)
|
|
return;
|
|
|
|
LLSD args;
|
|
std::string msgType;
|
|
if(ids.size() == 1)
|
|
{
|
|
LLUUID agent_id = ids[0];
|
|
std::string av_name;
|
|
if(LLAvatarNameCache::getPNSName(agent_id, av_name))
|
|
{
|
|
args["NAME"] = av_name;
|
|
}
|
|
|
|
msgType = "RemoveFromFriends";
|
|
}
|
|
else
|
|
{
|
|
msgType = "RemoveMultipleFromFriends";
|
|
}
|
|
|
|
LLSD payload;
|
|
for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
|
|
{
|
|
payload["ids"].append(*it);
|
|
}
|
|
|
|
LLNotificationsUtil::add(msgType,
|
|
args,
|
|
payload,
|
|
&handleRemove);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::offerTeleport(const LLUUID& invitee)
|
|
{
|
|
if (invitee.isNull())
|
|
return;
|
|
|
|
LLDynamicArray<LLUUID> ids;
|
|
ids.push_back(invitee);
|
|
offerTeleport(ids);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::offerTeleport(const uuid_vec_t& ids)
|
|
{
|
|
if (ids.size() == 0)
|
|
return;
|
|
|
|
handle_lure(ids);
|
|
}
|
|
|
|
static void on_avatar_name_cache_start_im(const LLUUID& agent_id, const LLAvatarName& av_name)
|
|
{
|
|
static LLCachedControl<bool> tear_off("OtherChatsTornOff");
|
|
if (!tear_off) gIMMgr->setFloaterOpen(true);
|
|
gIMMgr->addSession(LLCacheName::cleanFullName(av_name.getLegacyName()), IM_NOTHING_SPECIAL, agent_id);
|
|
make_ui_sound("UISndStartIM");
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::startIM(const LLUUID& id)
|
|
{
|
|
if (id.isNull() || gAgentID == id)
|
|
return;
|
|
|
|
// [RLVa:KB] - Checked: 2011-04-11 (RLVa-1.3.0h) | Added: RLVa-1.3.0h
|
|
if ( (rlv_handler_t::isEnabled()) && (!gRlvHandler.canStartIM(id)) )
|
|
{
|
|
LLUUID idSession = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
|
|
if ( (idSession.notNull()) && (!gIMMgr->hasSession(idSession)) )
|
|
{
|
|
make_ui_sound("UISndInvalidOp");
|
|
RlvUtil::notifyBlocked(RLV_STRING_BLOCKED_STARTIM, LLSD().with("RECIPIENT", id/*LLSLURL("agent", id, "completename").getSLURLString()*/));
|
|
return;
|
|
}
|
|
}
|
|
// [/RLVa:KB]
|
|
|
|
LLAvatarName av_name;
|
|
if (LLAvatarNameCache::get(id, &av_name)) // Bypass expiration, open NOW!
|
|
on_avatar_name_cache_start_im(id, av_name);
|
|
else
|
|
LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_cache_start_im, _1, _2));
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::endIM(const LLUUID& id)
|
|
{
|
|
if (id.isNull())
|
|
return;
|
|
|
|
LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
|
|
if (session_id.notNull())
|
|
{
|
|
gIMMgr->removeSession(session_id);
|
|
}
|
|
}
|
|
|
|
/* Singu TODO: Voice refactor
|
|
static void on_avatar_name_cache_start_call(const LLUUID& agent_id,
|
|
const LLAvatarName& av_name)
|
|
{
|
|
LLUUID session_id = gIMMgr->addSession(LLCacheName::cleanFullName(av_name.getLegacyName()), IM_NOTHING_SPECIAL, agent_id, true);
|
|
if (session_id.notNull())
|
|
{
|
|
gIMMgr->startCall(session_id);
|
|
}
|
|
make_ui_sound("UISndStartIM");
|
|
}
|
|
|
|
|
|
// static
|
|
void LLAvatarActions::startCall(const LLUUID& id)
|
|
{
|
|
if (id.isNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// [RLVa:KB] - Checked: 2011-04-11 (RLVa-1.3.0h) | Added: RLVa-1.3.0h
|
|
if ( (rlv_handler_t::isEnabled()) && (!gRlvHandler.canStartIM(id)) )
|
|
{
|
|
LLUUID idSession = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
|
|
if ( (idSession.notNull()) && (!gIMMgr->hasSession(idSession)) )
|
|
{
|
|
make_ui_sound("UISndInvalidOp");
|
|
RlvUtil::notifyBlocked(RLV_STRING_BLOCKED_STARTIM, LLSD().with("RECIPIENT", id));//LLSLURL("agent", id, "completename").getSLURLString()));
|
|
return;
|
|
}
|
|
}
|
|
// [/RLVa:KB]
|
|
|
|
LLAvatarNameCache::get(id,
|
|
boost::bind(&on_avatar_name_cache_start_call, _1, _2));
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::startAdhocCall(const uuid_vec_t& ids)
|
|
{
|
|
if (ids.size() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// convert vector into LLDynamicArray for addSession
|
|
LLDynamicArray<LLUUID> id_array;
|
|
for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
|
|
{
|
|
// [RLVa:KB] - Checked: 2011-04-11 (RLVa-1.3.0h) | Added: RLVa-1.3.0h
|
|
const LLUUID& idAgent = *it;
|
|
if ( (rlv_handler_t::isEnabled()) && (!gRlvHandler.canStartIM(idAgent)) )
|
|
{
|
|
make_ui_sound("UISndInvalidOp");
|
|
RlvUtil::notifyBlocked(RLV_STRING_BLOCKED_STARTCONF, LLSD().with("RECIPIENT", idAgent));//LLSLURL("agent", idAgent, "completename").getSLURLString()));
|
|
return;
|
|
}
|
|
id_array.push_back(idAgent);
|
|
// [/RLVa:KB]
|
|
// id_array.push_back(*it);
|
|
}
|
|
|
|
// create the new ad hoc voice session
|
|
const std::string title = LLTrans::getString("conference-title");
|
|
LLUUID session_id = gIMMgr->addSession(title, IM_SESSION_CONFERENCE_START,
|
|
ids[0], id_array, true);
|
|
if (session_id.isNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
gIMMgr->autoStartCallOnStartup(session_id);
|
|
|
|
make_ui_sound("UISndStartIM");
|
|
}
|
|
*/
|
|
|
|
/* AD *TODO: Is this function needed any more?
|
|
I fixed it a bit(added check for canCall), but it appears that it is not used
|
|
anywhere. Maybe it should be removed?
|
|
// static
|
|
bool LLAvatarActions::isCalling(const LLUUID &id)
|
|
{
|
|
if (id.isNull() || !canCall())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
|
|
return (LLIMModel::getInstance()->findIMSession(session_id) != NULL);
|
|
}*/
|
|
|
|
//static
|
|
bool LLAvatarActions::canCall()
|
|
{
|
|
return LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::startConference(const uuid_vec_t& ids)
|
|
{
|
|
for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
|
|
{
|
|
// [RLVa:KB] - Checked: 2011-04-11 (RLVa-1.3.0h) | Added: RLVa-1.3.0h
|
|
const LLUUID& idAgent = *it;
|
|
if ( (rlv_handler_t::isEnabled()) && (!gRlvHandler.canStartIM(idAgent)) )
|
|
{
|
|
make_ui_sound("UISndInvalidOp");
|
|
RlvUtil::notifyBlocked(RLV_STRING_BLOCKED_STARTCONF, LLSD().with("RECIPIENT", idAgent/*LLSLURL("agent", idAgent, "completename").getSLURLString()*/));
|
|
return;
|
|
}
|
|
// [/RLVa:KB]
|
|
}
|
|
static LLCachedControl<bool> tear_off("OtherChatsTornOff");
|
|
if (!tear_off) gIMMgr->setFloaterOpen(true);
|
|
const std::string title = LLTrans::getString("conference-title");
|
|
gIMMgr->addSession(title, IM_SESSION_CONFERENCE_START, ids[0], ids);
|
|
make_ui_sound("UISndStartIM");
|
|
}
|
|
|
|
/* Singu TODO: Web Profiles
|
|
static const char* get_profile_floater_name(const LLUUID& avatar_id)
|
|
{
|
|
// Use different floater XML for our profile to be able to save its rect.
|
|
return avatar_id == gAgentID ? "my_profile" : "profile";
|
|
}
|
|
*/
|
|
|
|
static void on_avatar_name_show_profile(const LLUUID& agent_id, const LLAvatarName& av_name)
|
|
{
|
|
//if (!gSavedSettings.getBOOL("UseWebProfiles")
|
|
//{
|
|
LLFloaterAvatarInfo* floater = LLFloaterAvatarInfo::getInstance(agent_id);
|
|
if(!floater)
|
|
{
|
|
floater = new LLFloaterAvatarInfo(LLTrans::getString("Command_Profile_Label")+" "+av_name.getCompleteName(), agent_id);
|
|
floater->center();
|
|
}
|
|
|
|
// ...bring that window to front
|
|
floater->open(); /*Flawfinder: ignore*/
|
|
//}
|
|
/*
|
|
else
|
|
{
|
|
std::string username = av_name.mUsername;
|
|
if (username.empty())
|
|
{
|
|
username = LLCacheName::buildUsername(av_name.mDisplayName);
|
|
}
|
|
|
|
llinfos << "opening web profile for " << username << llendl;
|
|
std::string url = getProfileURL(username);
|
|
|
|
// PROFILES: open in webkit window
|
|
LLFloaterWebContent::Params p;
|
|
p.url(url).
|
|
id(agent_id.asString());
|
|
LLFloaterReg::showInstance(get_profile_floater_name(agent_id), p);
|
|
}
|
|
*/
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::showProfile(const LLUUID& id)
|
|
{
|
|
if (id.notNull())
|
|
{
|
|
LLAvatarName av_name;
|
|
if (LLAvatarNameCache::get(id, &av_name)) // Bypass expiration, open NOW!
|
|
on_avatar_name_show_profile(id, av_name);
|
|
else
|
|
LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_show_profile, _1, _2));
|
|
}
|
|
}
|
|
|
|
//static
|
|
bool LLAvatarActions::profileVisible(const LLUUID& id)
|
|
{
|
|
LLFloater* browser = getProfileFloater(id);
|
|
return browser && browser->getVisible();
|
|
}
|
|
|
|
//static
|
|
LLFloater* LLAvatarActions::getProfileFloater(const LLUUID& id)
|
|
{
|
|
LLFloater* browser;
|
|
//if (!gSavedSettings.getBOOL("UseWebProfiles")
|
|
browser = LLFloaterAvatarInfo::getInstance(id);
|
|
/*else
|
|
browser = dynamic_cast<LLFloaterWebContent*>
|
|
(LLFloaterReg::findInstance(get_profile_floater_name(id), LLSD().with("id", id)));
|
|
*/
|
|
return browser;
|
|
}
|
|
|
|
//static
|
|
void LLAvatarActions::hideProfile(const LLUUID& id)
|
|
{
|
|
LLFloater* browser = getProfileFloater(id);
|
|
if (browser)
|
|
{
|
|
browser->close();
|
|
}
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::showOnMap(const LLUUID& id)
|
|
{
|
|
std::string av_name;
|
|
if (!LLAvatarNameCache::getPNSName(id, av_name))
|
|
{
|
|
LLAvatarNameCache::get(id, boost::bind(&LLAvatarActions::showOnMap, id));
|
|
return;
|
|
}
|
|
|
|
gFloaterWorldMap->trackAvatar(id, av_name);
|
|
LLFloaterWorldMap::show(true);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::pay(const LLUUID& id)
|
|
{
|
|
LLNotification::Params params("BusyModePay");
|
|
params.functor(boost::bind(&LLAvatarActions::handlePay, _1, _2, id));
|
|
|
|
if (gAgent.getBusy())
|
|
{
|
|
// warn users of being in busy mode during a transaction
|
|
LLNotifications::instance().add(params);
|
|
}
|
|
else
|
|
{
|
|
LLNotifications::instance().forceResponse(params, 1);
|
|
}
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::kick(const LLUUID& id)
|
|
{
|
|
LLSD payload;
|
|
payload["avatar_id"] = id;
|
|
LLNotifications::instance().add("KickUser", LLSD(), payload, handleKick);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::freeze(const LLUUID& id)
|
|
{
|
|
LLSD payload;
|
|
payload["avatar_id"] = id;
|
|
LLNotifications::instance().add("FreezeUser", LLSD(), payload, handleFreeze);
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::unfreeze(const LLUUID& id)
|
|
{
|
|
LLSD payload;
|
|
payload["avatar_id"] = id;
|
|
LLNotifications::instance().add("UnFreezeUser", LLSD(), payload, handleUnfreeze);
|
|
}
|
|
|
|
//static
|
|
void LLAvatarActions::csr(const LLUUID& id)
|
|
{
|
|
std::string name;
|
|
if (!gCacheName->getFullName(id, name)) return;
|
|
|
|
std::string url = "http://csr.lindenlab.com/agent/";
|
|
|
|
// slow and stupid, but it's late
|
|
S32 len = name.length();
|
|
for (S32 i = 0; i < len; i++)
|
|
{
|
|
if (name[i] == ' ')
|
|
{
|
|
url += "%20";
|
|
}
|
|
else
|
|
{
|
|
url += name[i];
|
|
}
|
|
}
|
|
|
|
LLWeb::loadURL(url);
|
|
}
|
|
|
|
// Singu TODO: Share inventory code block should live here
|
|
|
|
// static
|
|
void LLAvatarActions::toggleBlock(const LLUUID& id)
|
|
{
|
|
std::string name;
|
|
|
|
gCacheName->getFullName(id, name); // needed for mute
|
|
LLMute mute(id, name, LLMute::AGENT);
|
|
|
|
if (LLMuteList::getInstance()->isMuted(mute.mID, mute.mName))
|
|
{
|
|
LLMuteList::getInstance()->remove(mute);
|
|
}
|
|
else
|
|
{
|
|
LLMuteList::getInstance()->add(mute);
|
|
}
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::toggleMuteVoice(const LLUUID& id)
|
|
{
|
|
std::string name;
|
|
gCacheName->getFullName(id, name); // needed for mute
|
|
|
|
LLMuteList* mute_list = LLMuteList::getInstance();
|
|
bool is_muted = mute_list->isMuted(id, LLMute::flagVoiceChat);
|
|
|
|
LLMute mute(id, name, LLMute::AGENT);
|
|
if (!is_muted)
|
|
{
|
|
mute_list->add(mute, LLMute::flagVoiceChat);
|
|
}
|
|
else
|
|
{
|
|
mute_list->remove(mute, LLMute::flagVoiceChat);
|
|
}
|
|
}
|
|
|
|
// static
|
|
bool LLAvatarActions::canOfferTeleport(const LLUUID& id)
|
|
{
|
|
// First use LLAvatarTracker::isBuddy()
|
|
// If LLAvatarTracker::instance().isBuddyOnline function only is used
|
|
// then for avatars that are online and not a friend it will return false.
|
|
// But we should give an ability to offer a teleport for such avatars.
|
|
if(LLAvatarTracker::instance().isBuddy(id))
|
|
{
|
|
return LLAvatarTracker::instance().isBuddyOnline(id);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
bool LLAvatarActions::canOfferTeleport(const uuid_vec_t& ids)
|
|
{
|
|
// We can't send more than 250 lures in a single message, so disable this
|
|
// button when there are too many id's selected.
|
|
if(ids.size() > 250) return false;
|
|
|
|
bool result = true;
|
|
for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
|
|
{
|
|
if(!canOfferTeleport(*it))
|
|
{
|
|
result = false;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void LLAvatarActions::inviteToGroup(const LLUUID& id)
|
|
{
|
|
LLFloaterGroupPicker* widget = LLFloaterGroupPicker::showInstance(LLSD(id));
|
|
if (widget)
|
|
{
|
|
widget->center();
|
|
widget->setPowersMask(GP_MEMBER_INVITE);
|
|
//widget->removeNoneOption();
|
|
widget->setSelectCallback(callback_invite_to_group, (void*)&id);
|
|
}
|
|
}
|
|
|
|
//== private methods ========================================================================================
|
|
|
|
// static
|
|
bool LLAvatarActions::handleRemove(const LLSD& notification, const LLSD& response)
|
|
{
|
|
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
|
|
|
|
const LLSD& ids = notification["payload"]["ids"];
|
|
for (LLSD::array_const_iterator itr = ids.beginArray(); itr != ids.endArray(); ++itr)
|
|
{
|
|
LLUUID id = itr->asUUID();
|
|
const LLRelationship* ip = LLAvatarTracker::instance().getBuddyInfo(id);
|
|
if (ip)
|
|
{
|
|
switch (option)
|
|
{
|
|
case 0: // YES
|
|
if( ip->isRightGrantedTo(LLRelationship::GRANT_MODIFY_OBJECTS))
|
|
{
|
|
LLAvatarTracker::instance().empower(id, FALSE);
|
|
LLAvatarTracker::instance().notifyObservers();
|
|
}
|
|
LLAvatarTracker::instance().terminateBuddy(id);
|
|
LLAvatarTracker::instance().notifyObservers();
|
|
gInventory.addChangedMask(LLInventoryObserver::LABEL | LLInventoryObserver::CALLING_CARD, LLUUID::null);
|
|
gInventory.notifyObservers();
|
|
break;
|
|
|
|
case 1: // NO
|
|
default:
|
|
llinfos << "No removal performed." << llendl;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// static
|
|
bool LLAvatarActions::handlePay(const LLSD& notification, const LLSD& response, LLUUID avatar_id)
|
|
{
|
|
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
|
|
if (option == 0)
|
|
{
|
|
gAgent.clearBusy();
|
|
}
|
|
|
|
LLFloaterPay::payDirectly(&give_money, avatar_id, /*is_group=*/false);
|
|
return false;
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::callback_invite_to_group(LLUUID group_id, void* id)
|
|
{
|
|
uuid_vec_t agent_ids;
|
|
agent_ids.push_back(*static_cast<const LLUUID*>(id));
|
|
|
|
LLFloaterGroupInvite::showForGroup(group_id, &agent_ids);
|
|
}
|
|
|
|
|
|
// static
|
|
bool LLAvatarActions::callbackAddFriendWithMessage(const LLSD& notification, const LLSD& response)
|
|
{
|
|
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
|
|
if (option == 0)
|
|
{
|
|
requestFriendship(notification["payload"]["id"].asUUID(),
|
|
notification["payload"]["name"].asString(),
|
|
response["message"].asString());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// static
|
|
bool LLAvatarActions::handleKick(const LLSD& notification, const LLSD& response)
|
|
{
|
|
S32 option = LLNotification::getSelectedOption(notification, response);
|
|
|
|
if (option == 0)
|
|
{
|
|
LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
|
|
msg->newMessageFast(_PREHASH_GodKickUser);
|
|
msg->nextBlockFast(_PREHASH_UserInfo);
|
|
msg->addUUIDFast(_PREHASH_GodID, gAgent.getID() );
|
|
msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
|
|
msg->addUUIDFast(_PREHASH_AgentID, avatar_id );
|
|
msg->addU32("KickFlags", KICK_FLAGS_DEFAULT );
|
|
msg->addStringFast(_PREHASH_Reason, response["message"].asString() );
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
return false;
|
|
}
|
|
bool LLAvatarActions::handleFreeze(const LLSD& notification, const LLSD& response)
|
|
{
|
|
S32 option = LLNotification::getSelectedOption(notification, response);
|
|
|
|
if (option == 0)
|
|
{
|
|
LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
|
|
msg->newMessageFast(_PREHASH_GodKickUser);
|
|
msg->nextBlockFast(_PREHASH_UserInfo);
|
|
msg->addUUIDFast(_PREHASH_GodID, gAgent.getID() );
|
|
msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
|
|
msg->addUUIDFast(_PREHASH_AgentID, avatar_id );
|
|
msg->addU32("KickFlags", KICK_FLAGS_FREEZE );
|
|
msg->addStringFast(_PREHASH_Reason, response["message"].asString() );
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
return false;
|
|
}
|
|
bool LLAvatarActions::handleUnfreeze(const LLSD& notification, const LLSD& response)
|
|
{
|
|
S32 option = LLNotification::getSelectedOption(notification, response);
|
|
std::string text = response["message"].asString();
|
|
if (option == 0)
|
|
{
|
|
LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
|
|
LLMessageSystem* msg = gMessageSystem;
|
|
|
|
msg->newMessageFast(_PREHASH_GodKickUser);
|
|
msg->nextBlockFast(_PREHASH_UserInfo);
|
|
msg->addUUIDFast(_PREHASH_GodID, gAgent.getID() );
|
|
msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
|
|
msg->addUUIDFast(_PREHASH_AgentID, avatar_id );
|
|
msg->addU32("KickFlags", KICK_FLAGS_UNFREEZE );
|
|
msg->addStringFast(_PREHASH_Reason, text );
|
|
gAgent.sendReliableMessage();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// static
|
|
void LLAvatarActions::requestFriendship(const LLUUID& target_id, const std::string& target_name, const std::string& message)
|
|
{
|
|
const LLUUID calling_card_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
|
|
send_improved_im(target_id,
|
|
target_name,
|
|
message,
|
|
IM_ONLINE,
|
|
IM_FRIENDSHIP_OFFERED,
|
|
calling_card_folder_id);
|
|
|
|
LLSD args;
|
|
args["TO_NAME"] = target_name;
|
|
|
|
LLSD payload;
|
|
payload["from_id"] = target_id;
|
|
//payload["SUPPRESS_TOAST"] = true;
|
|
LLNotificationsUtil::add("FriendshipOffered", args, payload);
|
|
}
|
|
|
|
//static
|
|
bool LLAvatarActions::isFriend(const LLUUID& id)
|
|
{
|
|
return ( NULL != LLAvatarTracker::instance().getBuddyInfo(id) );
|
|
}
|
|
|
|
// static
|
|
bool LLAvatarActions::isBlocked(const LLUUID& id)
|
|
{
|
|
return LLMuteList::getInstance()->isMuted(id);
|
|
}
|
|
|
|
// static
|
|
bool LLAvatarActions::isVoiceMuted(const LLUUID& id)
|
|
{
|
|
return LLMuteList::getInstance()->isMuted(id, LLMute::flagVoiceChat);
|
|
}
|
|
|
|
// static
|
|
bool LLAvatarActions::canBlock(const LLUUID& id)
|
|
{
|
|
bool is_linden = LLMuteList::getInstance()->isLinden(id);
|
|
bool is_self = id == gAgentID;
|
|
return !is_self && !is_linden;
|
|
}
|
|
|