2678 lines
81 KiB
C++
2678 lines
81 KiB
C++
/**
|
|
* @file llpanelprofile.cpp
|
|
* @brief Profile panel implementation
|
|
*
|
|
* $LicenseInfo:firstyear=2022&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2022, 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 "llpanelprofile.h"
|
|
|
|
// Common
|
|
#include "llavatarnamecache.h"
|
|
#include "llsdutil.h"
|
|
#include "llslurl.h"
|
|
#include "lldateutil.h" //ageFromDate
|
|
|
|
// UI
|
|
#include "llavatariconctrl.h"
|
|
#include "llclipboard.h"
|
|
#include "llcheckboxctrl.h"
|
|
#include "llcombobox.h"
|
|
#include "lllineeditor.h"
|
|
#include "llloadingindicator.h"
|
|
#include "llmenubutton.h"
|
|
#include "lltabcontainer.h"
|
|
#include "lltextbox.h"
|
|
#include "lltexteditor.h"
|
|
#include "lltexturectrl.h"
|
|
#include "lltoggleablemenu.h"
|
|
#include "llgrouplist.h"
|
|
#include "llurlaction.h"
|
|
|
|
// Image
|
|
#include "llimagej2c.h"
|
|
|
|
// Newview
|
|
#include "llagent.h" //gAgent
|
|
#include "llagentpicksinfo.h"
|
|
#include "llavataractions.h"
|
|
#include "llavatarpropertiesprocessor.h"
|
|
#include "llcallingcard.h"
|
|
#include "llcommandhandler.h"
|
|
#include "llfloaterprofiletexture.h"
|
|
#include "llfloaterreg.h"
|
|
#include "llfloaterreporter.h"
|
|
#include "llfilepicker.h"
|
|
#include "llfirstuse.h"
|
|
#include "llgroupactions.h"
|
|
#include "lllogchat.h"
|
|
#include "llmutelist.h"
|
|
#include "llnotificationsutil.h"
|
|
#include "llpanelblockedlist.h"
|
|
#include "llpanelprofileclassifieds.h"
|
|
#include "llpanelprofilepicks.h"
|
|
#include "lltrans.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llviewermenu.h" //is_agent_mappable
|
|
#include "llviewermenufile.h"
|
|
#include "llviewertexturelist.h"
|
|
#include "llvoiceclient.h"
|
|
#include "llweb.h"
|
|
|
|
|
|
static LLPanelInjector<LLPanelProfileSecondLife> t_panel_profile_secondlife("panel_profile_secondlife");
|
|
static LLPanelInjector<LLPanelProfileWeb> t_panel_web("panel_profile_web");
|
|
static LLPanelInjector<LLPanelProfilePicks> t_panel_picks("panel_profile_picks");
|
|
static LLPanelInjector<LLPanelProfileFirstLife> t_panel_firstlife("panel_profile_firstlife");
|
|
static LLPanelInjector<LLPanelProfileNotes> t_panel_notes("panel_profile_notes");
|
|
static LLPanelInjector<LLPanelProfile> t_panel_profile("panel_profile");
|
|
|
|
static const std::string PANEL_SECONDLIFE = "panel_profile_secondlife";
|
|
static const std::string PANEL_WEB = "panel_profile_web";
|
|
static const std::string PANEL_PICKS = "panel_profile_picks";
|
|
static const std::string PANEL_CLASSIFIEDS = "panel_profile_classifieds";
|
|
static const std::string PANEL_FIRSTLIFE = "panel_profile_firstlife";
|
|
static const std::string PANEL_NOTES = "panel_profile_notes";
|
|
static const std::string PANEL_PROFILE_VIEW = "panel_profile_view";
|
|
|
|
static const std::string PROFILE_PROPERTIES_CAP = "AgentProfile";
|
|
static const std::string PROFILE_IMAGE_UPLOAD_CAP = "UploadAgentProfileImage";
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void request_avatar_properties_coro(std::string cap_url, LLUUID agent_id)
|
|
{
|
|
LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
|
|
LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
|
|
httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("request_avatar_properties_coro", httpPolicy));
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
|
|
LLCore::HttpHeaders::ptr_t httpHeaders;
|
|
|
|
LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
|
|
httpOpts->setFollowRedirects(true);
|
|
|
|
std::string finalUrl = cap_url + "/" + agent_id.asString();
|
|
|
|
LLSD result = httpAdapter->getAndSuspend(httpRequest, finalUrl, httpOpts, httpHeaders);
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
LL_DEBUGS("AvatarProperties") << "Agent id: " << agent_id << " Result: " << httpResults << LL_ENDL;
|
|
|
|
if (!status
|
|
|| !result.has("id")
|
|
|| agent_id != result["id"].asUUID())
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to get agent information for id " << agent_id << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLFloater* floater_profile = LLFloaterReg::findInstance("profile", LLSD().with("id", agent_id));
|
|
if (!floater_profile)
|
|
{
|
|
// floater is dead, so panels are dead as well
|
|
return;
|
|
}
|
|
|
|
LLPanel *panel = floater_profile->findChild<LLPanel>(PANEL_PROFILE_VIEW, TRUE);
|
|
LLPanelProfile *panel_profile = dynamic_cast<LLPanelProfile*>(panel);
|
|
if (!panel_profile)
|
|
{
|
|
LL_WARNS() << PANEL_PROFILE_VIEW << " not found" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
|
|
// Avatar Data
|
|
|
|
LLAvatarData *avatar_data = &panel_profile->mAvatarData;
|
|
std::string birth_date;
|
|
|
|
avatar_data->agent_id = agent_id;
|
|
avatar_data->avatar_id = agent_id;
|
|
avatar_data->image_id = result["sl_image_id"].asUUID();
|
|
avatar_data->fl_image_id = result["fl_image_id"].asUUID();
|
|
avatar_data->partner_id = result["partner_id"].asUUID();
|
|
avatar_data->about_text = result["sl_about_text"].asString();
|
|
avatar_data->fl_about_text = result["fl_about_text"].asString();
|
|
avatar_data->born_on = result["member_since"].asDate();
|
|
avatar_data->profile_url = getProfileURL(agent_id.asString());
|
|
|
|
avatar_data->flags = 0;
|
|
|
|
if (result["online"].asBoolean())
|
|
{
|
|
avatar_data->flags |= AVATAR_ONLINE;
|
|
}
|
|
if (result["allow_publish"].asBoolean())
|
|
{
|
|
avatar_data->flags |= AVATAR_ALLOW_PUBLISH;
|
|
}
|
|
if (result["identified"].asBoolean())
|
|
{
|
|
avatar_data->flags |= AVATAR_IDENTIFIED;
|
|
}
|
|
if (result["transacted"].asBoolean())
|
|
{
|
|
avatar_data->flags |= AVATAR_TRANSACTED;
|
|
}
|
|
|
|
avatar_data->caption_index = 0;
|
|
if (result.has("charter_member")) // won't be present if "caption" is set
|
|
{
|
|
avatar_data->caption_index = result["charter_member"].asInteger();
|
|
}
|
|
else if (result.has("caption"))
|
|
{
|
|
avatar_data->caption_text = result["caption"].asString();
|
|
}
|
|
|
|
panel = floater_profile->findChild<LLPanel>(PANEL_SECONDLIFE, TRUE);
|
|
LLPanelProfileSecondLife *panel_sl = dynamic_cast<LLPanelProfileSecondLife*>(panel);
|
|
if (panel_sl)
|
|
{
|
|
panel_sl->processProfileProperties(avatar_data);
|
|
}
|
|
|
|
panel = floater_profile->findChild<LLPanel>(PANEL_WEB, TRUE);
|
|
LLPanelProfileWeb *panel_web = dynamic_cast<LLPanelProfileWeb*>(panel);
|
|
if (panel_web)
|
|
{
|
|
panel_web->setLoaded();
|
|
}
|
|
|
|
panel = floater_profile->findChild<LLPanel>(PANEL_FIRSTLIFE, TRUE);
|
|
LLPanelProfileFirstLife *panel_first = dynamic_cast<LLPanelProfileFirstLife*>(panel);
|
|
if (panel_first)
|
|
{
|
|
panel_first->processProperties(avatar_data);
|
|
}
|
|
|
|
// Picks
|
|
|
|
LLSD picks_array = result["picks"];
|
|
LLAvatarPicks avatar_picks;
|
|
avatar_picks.agent_id = agent_id; // Not in use?
|
|
avatar_picks.target_id = agent_id;
|
|
|
|
for (LLSD::array_const_iterator it = picks_array.beginArray(); it != picks_array.endArray(); ++it)
|
|
{
|
|
const LLSD& pick_data = *it;
|
|
avatar_picks.picks_list.emplace_back(pick_data["id"].asUUID(), pick_data["name"].asString());
|
|
}
|
|
|
|
panel = floater_profile->findChild<LLPanel>(PANEL_PICKS, TRUE);
|
|
LLPanelProfilePicks *panel_picks = dynamic_cast<LLPanelProfilePicks*>(panel);
|
|
if (panel_picks)
|
|
{
|
|
// Refresh pick limit before processing
|
|
LLAgentPicksInfo::getInstance()->onServerRespond(&avatar_picks);
|
|
panel_picks->processProperties(&avatar_picks);
|
|
}
|
|
|
|
// Groups
|
|
|
|
LLSD groups_array = result["groups"];
|
|
LLAvatarGroups avatar_groups;
|
|
avatar_groups.agent_id = agent_id; // Not in use?
|
|
avatar_groups.avatar_id = agent_id; // target_id
|
|
|
|
for (LLSD::array_const_iterator it = groups_array.beginArray(); it != groups_array.endArray(); ++it)
|
|
{
|
|
const LLSD& group_info = *it;
|
|
LLAvatarGroups::LLGroupData group_data;
|
|
group_data.group_powers = 0; // Not in use?
|
|
group_data.group_title = group_info["name"].asString(); // Missing data, not in use?
|
|
group_data.group_id = group_info["id"].asUUID();
|
|
group_data.group_name = group_info["name"].asString();
|
|
group_data.group_insignia_id = group_info["image_id"].asUUID();
|
|
|
|
avatar_groups.group_list.push_back(group_data);
|
|
}
|
|
|
|
if (panel_sl)
|
|
{
|
|
panel_sl->processGroupProperties(&avatar_groups);
|
|
}
|
|
|
|
// Notes
|
|
LLAvatarNotes avatar_notes;
|
|
|
|
avatar_notes.agent_id = agent_id;
|
|
avatar_notes.target_id = agent_id;
|
|
avatar_notes.notes = result["notes"].asString();
|
|
|
|
panel = floater_profile->findChild<LLPanel>(PANEL_NOTES, TRUE);
|
|
LLPanelProfileNotes *panel_notes = dynamic_cast<LLPanelProfileNotes*>(panel);
|
|
if (panel_notes)
|
|
{
|
|
panel_notes->processProperties(&avatar_notes);
|
|
}
|
|
}
|
|
|
|
//TODO: changes take two minutes to propagate!
|
|
// Add some storage that holds updated data for two minutes
|
|
// for new instances to reuse the data
|
|
// Profile data is only relevant to won avatar, but notes
|
|
// are for everybody
|
|
void put_avatar_properties_coro(std::string cap_url, LLUUID agent_id, LLSD data)
|
|
{
|
|
LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
|
|
LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
|
|
httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("put_avatar_properties_coro", httpPolicy));
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
|
|
LLCore::HttpHeaders::ptr_t httpHeaders;
|
|
|
|
LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
|
|
httpOpts->setFollowRedirects(true);
|
|
|
|
std::string finalUrl = cap_url + "/" + agent_id.asString();
|
|
|
|
LLSD result = httpAdapter->putAndSuspend(httpRequest, finalUrl, data, httpOpts, httpHeaders);
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
if (!status)
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to put agent information " << data << " for id " << agent_id << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LL_DEBUGS("AvatarProperties") << "Agent id: " << agent_id << " Data: " << data << " Result: " << httpResults << LL_ENDL;
|
|
}
|
|
|
|
LLUUID post_profile_image(std::string cap_url, const LLSD &first_data, std::string path_to_image, LLHandle<LLPanel> *handle)
|
|
{
|
|
LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
|
|
LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
|
|
httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("post_profile_image_coro", httpPolicy));
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
|
|
LLCore::HttpHeaders::ptr_t httpHeaders;
|
|
|
|
LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
|
|
httpOpts->setFollowRedirects(true);
|
|
|
|
LLSD result = httpAdapter->postAndSuspend(httpRequest, cap_url, first_data, httpOpts, httpHeaders);
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
if (!status)
|
|
{
|
|
// todo: notification?
|
|
LL_WARNS("AvatarProperties") << "Failed to get uploader cap " << status.toString() << LL_ENDL;
|
|
return LLUUID::null;
|
|
}
|
|
if (!result.has("uploader"))
|
|
{
|
|
// todo: notification?
|
|
LL_WARNS("AvatarProperties") << "Failed to get uploader cap, response contains no data." << LL_ENDL;
|
|
return LLUUID::null;
|
|
}
|
|
std::string uploader_cap = result["uploader"].asString();
|
|
if (uploader_cap.empty())
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to get uploader cap, cap invalid." << LL_ENDL;
|
|
return LLUUID::null;
|
|
}
|
|
|
|
// Upload the image
|
|
|
|
LLCore::HttpRequest::ptr_t uploaderhttpRequest(new LLCore::HttpRequest);
|
|
LLCore::HttpHeaders::ptr_t uploaderhttpHeaders(new LLCore::HttpHeaders);
|
|
LLCore::HttpOptions::ptr_t uploaderhttpOpts(new LLCore::HttpOptions);
|
|
S64 length;
|
|
|
|
{
|
|
llifstream instream(path_to_image.c_str(), std::iostream::binary | std::iostream::ate);
|
|
if (!instream.is_open())
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to open file " << path_to_image << LL_ENDL;
|
|
return LLUUID::null;
|
|
}
|
|
length = instream.tellg();
|
|
}
|
|
|
|
uploaderhttpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, "application/jp2"); // optional
|
|
uploaderhttpHeaders->append(HTTP_OUT_HEADER_CONTENT_LENGTH, llformat("%d", length)); // required!
|
|
uploaderhttpOpts->setFollowRedirects(true);
|
|
|
|
result = httpAdapter->postFileAndSuspend(uploaderhttpRequest, uploader_cap, path_to_image, uploaderhttpOpts, uploaderhttpHeaders);
|
|
|
|
httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
LL_WARNS("AvatarProperties") << result << LL_ENDL;
|
|
|
|
if (!status)
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to upload image " << status.toString() << LL_ENDL;
|
|
return LLUUID::null;
|
|
}
|
|
|
|
if (result["state"].asString() != "complete")
|
|
{
|
|
if (result.has("message"))
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to upload image, state " << result["state"] << " message: " << result["message"] << LL_ENDL;
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to upload image " << result << LL_ENDL;
|
|
}
|
|
return LLUUID::null;
|
|
}
|
|
|
|
return result["new_asset"].asUUID();
|
|
}
|
|
|
|
enum EProfileImageType
|
|
{
|
|
PROFILE_IMAGE_SL,
|
|
PROFILE_IMAGE_FL,
|
|
};
|
|
|
|
void post_profile_image_coro(std::string cap_url, EProfileImageType type, std::string path_to_image, LLHandle<LLPanel> *handle)
|
|
{
|
|
LLSD data;
|
|
switch (type)
|
|
{
|
|
case PROFILE_IMAGE_SL:
|
|
data["profile-image-asset"] = "sl_image_id";
|
|
break;
|
|
case PROFILE_IMAGE_FL:
|
|
data["profile-image-asset"] = "fl_image_id";
|
|
break;
|
|
}
|
|
|
|
LLUUID result = post_profile_image(cap_url, data, path_to_image, handle);
|
|
|
|
// reset loading indicator
|
|
if (!handle->isDead())
|
|
{
|
|
switch (type)
|
|
{
|
|
case PROFILE_IMAGE_SL:
|
|
{
|
|
LLPanelProfileSecondLife* panel = static_cast<LLPanelProfileSecondLife*>(handle->get());
|
|
if (result.notNull())
|
|
{
|
|
panel->setProfileImageUploaded(result);
|
|
}
|
|
else
|
|
{
|
|
// failure, just stop progress indicator
|
|
panel->setProfileImageUploading(false);
|
|
}
|
|
break;
|
|
}
|
|
case PROFILE_IMAGE_FL:
|
|
{
|
|
LLPanelProfileFirstLife* panel = static_cast<LLPanelProfileFirstLife*>(handle->get());
|
|
if (result.notNull())
|
|
{
|
|
panel->setProfileImageUploaded(result);
|
|
}
|
|
else
|
|
{
|
|
// failure, just stop progress indicator
|
|
panel->setProfileImageUploading(false);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Cleanup
|
|
LLFile::remove(path_to_image);
|
|
delete handle;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// LLProfileHandler
|
|
|
|
class LLProfileHandler : public LLCommandHandler
|
|
{
|
|
public:
|
|
// requires trusted browser to trigger
|
|
LLProfileHandler() : LLCommandHandler("profile", UNTRUSTED_THROTTLE) { }
|
|
|
|
bool handle(const LLSD& params, const LLSD& query_map,
|
|
LLMediaCtrl* web)
|
|
{
|
|
if (params.size() < 1) return false;
|
|
std::string agent_name = params[0];
|
|
LL_INFOS() << "Profile, agent_name " << agent_name << LL_ENDL;
|
|
std::string url = getProfileURL(agent_name);
|
|
LLWeb::loadURLInternal(url);
|
|
|
|
return true;
|
|
}
|
|
};
|
|
LLProfileHandler gProfileHandler;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// LLAgentHandler
|
|
|
|
class LLAgentHandler : public LLCommandHandler
|
|
{
|
|
public:
|
|
// requires trusted browser to trigger
|
|
LLAgentHandler() : LLCommandHandler("agent", UNTRUSTED_THROTTLE) { }
|
|
|
|
virtual bool canHandleUntrusted(
|
|
const LLSD& params,
|
|
const LLSD& query_map,
|
|
LLMediaCtrl* web,
|
|
const std::string& nav_type)
|
|
{
|
|
if (params.size() < 2)
|
|
{
|
|
return true; // don't block, will fail later
|
|
}
|
|
|
|
if (nav_type == NAV_TYPE_CLICKED)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
const std::string verb = params[1].asString();
|
|
if (verb == "about" || verb == "inspect" || verb == "reportAbuse")
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool handle(const LLSD& params, const LLSD& query_map,
|
|
LLMediaCtrl* web)
|
|
{
|
|
if (params.size() < 2) return false;
|
|
LLUUID avatar_id;
|
|
if (!avatar_id.set(params[0], FALSE))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const std::string verb = params[1].asString();
|
|
if (verb == "about")
|
|
{
|
|
LLAvatarActions::showProfile(avatar_id);
|
|
return true;
|
|
}
|
|
|
|
if (verb == "inspect")
|
|
{
|
|
LLFloaterReg::showInstance("inspect_avatar", LLSD().with("avatar_id", avatar_id));
|
|
return true;
|
|
}
|
|
|
|
if (verb == "im")
|
|
{
|
|
LLAvatarActions::startIM(avatar_id);
|
|
return true;
|
|
}
|
|
|
|
if (verb == "pay")
|
|
{
|
|
if (!LLUI::getInstance()->mSettingGroups["config"]->getBOOL("EnableAvatarPay"))
|
|
{
|
|
LLNotificationsUtil::add("NoAvatarPay", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
|
|
return true;
|
|
}
|
|
|
|
LLAvatarActions::pay(avatar_id);
|
|
return true;
|
|
}
|
|
|
|
if (verb == "offerteleport")
|
|
{
|
|
LLAvatarActions::offerTeleport(avatar_id);
|
|
return true;
|
|
}
|
|
|
|
if (verb == "requestfriend")
|
|
{
|
|
LLAvatarActions::requestFriendshipDialog(avatar_id);
|
|
return true;
|
|
}
|
|
|
|
if (verb == "removefriend")
|
|
{
|
|
LLAvatarActions::removeFriendDialog(avatar_id);
|
|
return true;
|
|
}
|
|
|
|
if (verb == "mute")
|
|
{
|
|
if (! LLAvatarActions::isBlocked(avatar_id))
|
|
{
|
|
LLAvatarActions::toggleBlock(avatar_id);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (verb == "unmute")
|
|
{
|
|
if (LLAvatarActions::isBlocked(avatar_id))
|
|
{
|
|
LLAvatarActions::toggleBlock(avatar_id);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (verb == "block")
|
|
{
|
|
if (params.size() > 2)
|
|
{
|
|
const std::string object_name = LLURI::unescape(params[2].asString());
|
|
LLMute mute(avatar_id, object_name, LLMute::OBJECT);
|
|
LLMuteList::getInstance()->add(mute);
|
|
LLPanelBlockedList::showPanelAndSelect(mute.mID);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (verb == "unblock")
|
|
{
|
|
if (params.size() > 2)
|
|
{
|
|
const std::string object_name = params[2].asString();
|
|
LLMute mute(avatar_id, object_name, LLMute::OBJECT);
|
|
LLMuteList::getInstance()->remove(mute);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// reportAbuse is here due to convoluted avatar handling
|
|
// in LLScrollListCtrl and LLTextBase
|
|
if (verb == "reportAbuse" && web == NULL)
|
|
{
|
|
LLAvatarName av_name;
|
|
if (LLAvatarNameCache::get(avatar_id, &av_name))
|
|
{
|
|
LLFloaterReporter::showFromAvatar(avatar_id, av_name.getCompleteName());
|
|
}
|
|
else
|
|
{
|
|
LLFloaterReporter::showFromAvatar(avatar_id, "not avaliable");
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
LLAgentHandler gAgentHandler;
|
|
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// LLFloaterProfilePermissions
|
|
///----------------------------------------------------------------------------
|
|
|
|
class LLFloaterProfilePermissions
|
|
: public LLFloater
|
|
, public LLFriendObserver
|
|
{
|
|
public:
|
|
LLFloaterProfilePermissions(LLView * owner, const LLUUID &avatar_id);
|
|
~LLFloaterProfilePermissions();
|
|
BOOL postBuild() override;
|
|
void onOpen(const LLSD& key) override;
|
|
void draw() override;
|
|
void changed(U32 mask) override; // LLFriendObserver
|
|
|
|
void onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name);
|
|
bool hasUnsavedChanges() { return mHasUnsavedPermChanges; }
|
|
|
|
void onApplyRights();
|
|
|
|
private:
|
|
void fillRightsData();
|
|
void rightsConfirmationCallback(const LLSD& notification, const LLSD& response);
|
|
void confirmModifyRights(bool grant);
|
|
void onCommitSeeOnlineRights();
|
|
void onCommitEditRights();
|
|
void onCancel();
|
|
|
|
LLTextBase* mDescription;
|
|
LLCheckBoxCtrl* mOnlineStatus;
|
|
LLCheckBoxCtrl* mMapRights;
|
|
LLCheckBoxCtrl* mEditObjectRights;
|
|
LLButton* mOkBtn;
|
|
LLButton* mCancelBtn;
|
|
|
|
LLUUID mAvatarID;
|
|
F32 mContextConeOpacity;
|
|
bool mHasUnsavedPermChanges;
|
|
LLHandle<LLView> mOwnerHandle;
|
|
|
|
boost::signals2::connection mAvatarNameCacheConnection;
|
|
};
|
|
|
|
LLFloaterProfilePermissions::LLFloaterProfilePermissions(LLView * owner, const LLUUID &avatar_id)
|
|
: LLFloater(LLSD())
|
|
, mAvatarID(avatar_id)
|
|
, mContextConeOpacity(0.0f)
|
|
, mHasUnsavedPermChanges(false)
|
|
, mOwnerHandle(owner->getHandle())
|
|
{
|
|
buildFromFile("floater_profile_permissions.xml");
|
|
}
|
|
|
|
LLFloaterProfilePermissions::~LLFloaterProfilePermissions()
|
|
{
|
|
mAvatarNameCacheConnection.disconnect();
|
|
if (mAvatarID.notNull())
|
|
{
|
|
LLAvatarTracker::instance().removeParticularFriendObserver(mAvatarID, this);
|
|
}
|
|
}
|
|
|
|
BOOL LLFloaterProfilePermissions::postBuild()
|
|
{
|
|
mDescription = getChild<LLTextBase>("perm_description");
|
|
mOnlineStatus = getChild<LLCheckBoxCtrl>("online_check");
|
|
mMapRights = getChild<LLCheckBoxCtrl>("map_check");
|
|
mEditObjectRights = getChild<LLCheckBoxCtrl>("objects_check");
|
|
mOkBtn = getChild<LLButton>("perms_btn_ok");
|
|
mCancelBtn = getChild<LLButton>("perms_btn_cancel");
|
|
|
|
mOnlineStatus->setCommitCallback([this](LLUICtrl*, void*) { onCommitSeeOnlineRights(); }, nullptr);
|
|
mMapRights->setCommitCallback([this](LLUICtrl*, void*) { mHasUnsavedPermChanges = true; }, nullptr);
|
|
mEditObjectRights->setCommitCallback([this](LLUICtrl*, void*) { onCommitEditRights(); }, nullptr);
|
|
mOkBtn->setCommitCallback([this](LLUICtrl*, void*) { onApplyRights(); }, nullptr);
|
|
mCancelBtn->setCommitCallback([this](LLUICtrl*, void*) { onCancel(); }, nullptr);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::onOpen(const LLSD& key)
|
|
{
|
|
if (LLAvatarActions::isFriend(mAvatarID))
|
|
{
|
|
LLAvatarTracker::instance().addParticularFriendObserver(mAvatarID, this);
|
|
fillRightsData();
|
|
}
|
|
|
|
mCancelBtn->setFocus(true);
|
|
|
|
mAvatarNameCacheConnection = LLAvatarNameCache::get(mAvatarID, boost::bind(&LLFloaterProfilePermissions::onAvatarNameCache, this, _1, _2));
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::draw()
|
|
{
|
|
// drawFrustum
|
|
LLView *owner = mOwnerHandle.get();
|
|
static LLCachedControl<F32> max_opacity(gSavedSettings, "PickerContextOpacity", 0.4f);
|
|
drawConeToOwner(mContextConeOpacity, max_opacity, owner);
|
|
LLFloater::draw();
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::changed(U32 mask)
|
|
{
|
|
if (mask != LLFriendObserver::ONLINE)
|
|
{
|
|
fillRightsData();
|
|
}
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name)
|
|
{
|
|
mAvatarNameCacheConnection.disconnect();
|
|
|
|
LLStringUtil::format_map_t args;
|
|
args["[AGENT_NAME]"] = av_name.getDisplayName();
|
|
std::string descritpion = getString("description_string", args);
|
|
mDescription->setValue(descritpion);
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::fillRightsData()
|
|
{
|
|
const LLRelationship* relation = LLAvatarTracker::instance().getBuddyInfo(mAvatarID);
|
|
// If true - we are viewing friend's profile, enable check boxes and set values.
|
|
if (relation)
|
|
{
|
|
S32 rights = relation->getRightsGrantedTo();
|
|
|
|
BOOL see_online = LLRelationship::GRANT_ONLINE_STATUS & rights ? TRUE : FALSE;
|
|
mOnlineStatus->setValue(see_online);
|
|
mMapRights->setEnabled(see_online);
|
|
mMapRights->setValue(LLRelationship::GRANT_MAP_LOCATION & rights ? TRUE : FALSE);
|
|
mEditObjectRights->setValue(LLRelationship::GRANT_MODIFY_OBJECTS & rights ? TRUE : FALSE);
|
|
}
|
|
else
|
|
{
|
|
closeFloater();
|
|
LL_INFOS("ProfilePermissions") << "Floater closing since agent is no longer a friend" << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::rightsConfirmationCallback(const LLSD& notification,
|
|
const LLSD& response)
|
|
{
|
|
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
|
|
if (option != 0) // canceled
|
|
{
|
|
mEditObjectRights->setValue(mEditObjectRights->getValue().asBoolean() ? FALSE : TRUE);
|
|
}
|
|
else
|
|
{
|
|
mHasUnsavedPermChanges = true;
|
|
}
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::confirmModifyRights(bool grant)
|
|
{
|
|
LLSD args;
|
|
args["NAME"] = LLSLURL("agent", mAvatarID, "completename").getSLURLString();
|
|
LLNotificationsUtil::add(grant ? "GrantModifyRights" : "RevokeModifyRights", args, LLSD(),
|
|
boost::bind(&LLFloaterProfilePermissions::rightsConfirmationCallback, this, _1, _2));
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::onCommitSeeOnlineRights()
|
|
{
|
|
bool see_online = mOnlineStatus->getValue().asBoolean();
|
|
mMapRights->setEnabled(see_online);
|
|
if (see_online)
|
|
{
|
|
const LLRelationship* relation = LLAvatarTracker::instance().getBuddyInfo(mAvatarID);
|
|
if (relation)
|
|
{
|
|
S32 rights = relation->getRightsGrantedTo();
|
|
mMapRights->setValue(LLRelationship::GRANT_MAP_LOCATION & rights ? TRUE : FALSE);
|
|
}
|
|
else
|
|
{
|
|
closeFloater();
|
|
LL_INFOS("ProfilePermissions") << "Floater closing since agent is no longer a friend" << LL_ENDL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mMapRights->setValue(FALSE);
|
|
}
|
|
mHasUnsavedPermChanges = true;
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::onCommitEditRights()
|
|
{
|
|
const LLRelationship* buddy_relationship = LLAvatarTracker::instance().getBuddyInfo(mAvatarID);
|
|
|
|
if (!buddy_relationship)
|
|
{
|
|
LL_WARNS("ProfilePermissions") << "Trying to modify rights for non-friend avatar. Closing floater." << LL_ENDL;
|
|
closeFloater();
|
|
return;
|
|
}
|
|
|
|
bool allow_modify_objects = mEditObjectRights->getValue().asBoolean();
|
|
|
|
// if modify objects checkbox clicked
|
|
if (buddy_relationship->isRightGrantedTo(
|
|
LLRelationship::GRANT_MODIFY_OBJECTS) != allow_modify_objects)
|
|
{
|
|
confirmModifyRights(allow_modify_objects);
|
|
}
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::onApplyRights()
|
|
{
|
|
const LLRelationship* buddy_relationship = LLAvatarTracker::instance().getBuddyInfo(mAvatarID);
|
|
|
|
if (!buddy_relationship)
|
|
{
|
|
LL_WARNS("ProfilePermissions") << "Trying to modify rights for non-friend avatar. Skipped." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
S32 rights = 0;
|
|
|
|
if (mOnlineStatus->getValue().asBoolean())
|
|
{
|
|
rights |= LLRelationship::GRANT_ONLINE_STATUS;
|
|
}
|
|
if (mMapRights->getValue().asBoolean())
|
|
{
|
|
rights |= LLRelationship::GRANT_MAP_LOCATION;
|
|
}
|
|
if (mEditObjectRights->getValue().asBoolean())
|
|
{
|
|
rights |= LLRelationship::GRANT_MODIFY_OBJECTS;
|
|
}
|
|
|
|
LLAvatarPropertiesProcessor::getInstance()->sendFriendRights(mAvatarID, rights);
|
|
|
|
closeFloater();
|
|
}
|
|
|
|
void LLFloaterProfilePermissions::onCancel()
|
|
{
|
|
closeFloater();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// LLPanelProfileSecondLife
|
|
|
|
LLPanelProfileSecondLife::LLPanelProfileSecondLife()
|
|
: LLPanelProfileTab()
|
|
, mAvatarNameCacheConnection()
|
|
, mHasUnsavedDescriptionChanges(false)
|
|
, mWaitingForImageUpload(false)
|
|
, mAllowPublish(false)
|
|
{
|
|
}
|
|
|
|
LLPanelProfileSecondLife::~LLPanelProfileSecondLife()
|
|
{
|
|
if (getAvatarId().notNull())
|
|
{
|
|
LLAvatarTracker::instance().removeParticularFriendObserver(getAvatarId(), this);
|
|
}
|
|
|
|
if (LLVoiceClient::instanceExists())
|
|
{
|
|
LLVoiceClient::getInstance()->removeObserver((LLVoiceClientStatusObserver*)this);
|
|
}
|
|
|
|
if (mAvatarNameCacheConnection.connected())
|
|
{
|
|
mAvatarNameCacheConnection.disconnect();
|
|
}
|
|
}
|
|
|
|
BOOL LLPanelProfileSecondLife::postBuild()
|
|
{
|
|
mGroupList = getChild<LLGroupList>("group_list");
|
|
mShowInSearchCombo = getChild<LLComboBox>("show_in_search");
|
|
mSecondLifePic = getChild<LLIconCtrl>("2nd_life_pic");
|
|
mSecondLifePicLayout = getChild<LLPanel>("image_panel");
|
|
mDescriptionEdit = getChild<LLTextEditor>("sl_description_edit");
|
|
mAgentActionMenuButton = getChild<LLMenuButton>("agent_actions_menu");
|
|
mSaveDescriptionChanges = getChild<LLButton>("save_description_changes");
|
|
mDiscardDescriptionChanges = getChild<LLButton>("discard_description_changes");
|
|
mCanSeeOnlineIcon = getChild<LLIconCtrl>("can_see_online");
|
|
mCantSeeOnlineIcon = getChild<LLIconCtrl>("cant_see_online");
|
|
mCanSeeOnMapIcon = getChild<LLIconCtrl>("can_see_on_map");
|
|
mCantSeeOnMapIcon = getChild<LLIconCtrl>("cant_see_on_map");
|
|
mCanEditObjectsIcon = getChild<LLIconCtrl>("can_edit_objects");
|
|
mCantEditObjectsIcon = getChild<LLIconCtrl>("cant_edit_objects");
|
|
|
|
mShowInSearchCombo->setCommitCallback([this](LLUICtrl*, void*) { onShowInSearchCallback(); }, nullptr);
|
|
mGroupList->setDoubleClickCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { LLPanelProfileSecondLife::openGroupProfile(); });
|
|
mGroupList->setReturnCallback([this](LLUICtrl*, const LLSD&) { LLPanelProfileSecondLife::openGroupProfile(); });
|
|
mSaveDescriptionChanges->setCommitCallback([this](LLUICtrl*, void*) { onSaveDescriptionChanges(); }, nullptr);
|
|
mDiscardDescriptionChanges->setCommitCallback([this](LLUICtrl*, void*) { onDiscardDescriptionChanges(); }, nullptr);
|
|
mDescriptionEdit->setKeystrokeCallback([this](LLTextEditor* caller) { onSetDescriptionDirty(); });
|
|
|
|
mCanSeeOnlineIcon->setMouseUpCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { onShowAgentPermissionsDialog(); });
|
|
mCantSeeOnlineIcon->setMouseUpCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { onShowAgentPermissionsDialog(); });
|
|
mCanSeeOnMapIcon->setMouseUpCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { onShowAgentPermissionsDialog(); });
|
|
mCantSeeOnMapIcon->setMouseUpCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { onShowAgentPermissionsDialog(); });
|
|
mCanEditObjectsIcon->setMouseUpCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { onShowAgentPermissionsDialog(); });
|
|
mCantEditObjectsIcon->setMouseUpCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { onShowAgentPermissionsDialog(); });
|
|
mSecondLifePic->setMouseUpCallback([this](LLUICtrl*, S32 x, S32 y, MASK mask) { onShowAgentProfileTexture(); });
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onOpen(const LLSD& key)
|
|
{
|
|
LLPanelProfileTab::onOpen(key);
|
|
|
|
resetData();
|
|
|
|
LLUUID avatar_id = getAvatarId();
|
|
|
|
BOOL own_profile = getSelfProfile();
|
|
|
|
mGroupList->setShowNone(!own_profile);
|
|
|
|
childSetVisible("notes_panel", !own_profile);
|
|
childSetVisible("settings_panel", own_profile);
|
|
childSetVisible("about_buttons_panel", own_profile);
|
|
|
|
if (own_profile)
|
|
{
|
|
// Group list control cannot toggle ForAgent loading
|
|
// Less than ideal, but viewing own profile via search is edge case
|
|
mGroupList->enableForAgent(false);
|
|
}
|
|
|
|
// Init menu, menu needs to be created in scope of a registar to work correctly.
|
|
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar commit;
|
|
commit.add("Profile.Commit", [this](LLUICtrl*, const LLSD& userdata) { onCommitMenu(userdata); });
|
|
|
|
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable;
|
|
enable.add("Profile.EnableItem", [this](LLUICtrl*, const LLSD& userdata) { return onEnableMenu(userdata); });
|
|
enable.add("Profile.CheckItem", [this](LLUICtrl*, const LLSD& userdata) { return onCheckMenu(userdata); });
|
|
|
|
if (own_profile)
|
|
{
|
|
mAgentActionMenuButton->setMenu("menu_profile_self.xml", LLMenuButton::MP_BOTTOM_RIGHT);
|
|
}
|
|
else
|
|
{
|
|
// Todo: use PeopleContextMenu instead?
|
|
mAgentActionMenuButton->setMenu("menu_profile_other.xml", LLMenuButton::MP_BOTTOM_RIGHT);
|
|
}
|
|
|
|
mDescriptionEdit->setParseHTML(!own_profile);
|
|
|
|
if (!own_profile)
|
|
{
|
|
mVoiceStatus = LLAvatarActions::canCall() && (LLAvatarActions::isFriend(avatar_id) ? LLAvatarTracker::instance().isBuddyOnline(avatar_id) : TRUE);
|
|
updateOnlineStatus();
|
|
fillRightsData();
|
|
}
|
|
|
|
mAvatarNameCacheConnection = LLAvatarNameCache::get(getAvatarId(), boost::bind(&LLPanelProfileSecondLife::onAvatarNameCache, this, _1, _2));
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::updateData()
|
|
{
|
|
LLUUID avatar_id = getAvatarId();
|
|
if (!getStarted() && avatar_id.notNull())
|
|
{
|
|
setIsLoading();
|
|
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLCoros::instance().launch("requestAgentUserInfoCoro",
|
|
boost::bind(request_avatar_properties_coro, cap_url, avatar_id));
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS() << "Failed to update profile data, no cap found" << LL_ENDL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::refreshName()
|
|
{
|
|
if (!mAvatarNameCacheConnection.connected())
|
|
{
|
|
mAvatarNameCacheConnection = LLAvatarNameCache::get(getAvatarId(), boost::bind(&LLPanelProfileSecondLife::onAvatarNameCache, this, _1, _2));
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::resetData()
|
|
{
|
|
resetLoading();
|
|
|
|
// Set default image and 1:1 dimensions for it
|
|
mSecondLifePic->setValue("Generic_Person_Large");
|
|
mImageId = LLUUID::null;
|
|
|
|
LLRect imageRect = mSecondLifePicLayout->getRect();
|
|
mSecondLifePicLayout->reshape(imageRect.getHeight(), imageRect.getHeight());
|
|
|
|
setDescriptionText(LLStringUtil::null);
|
|
mGroups.clear();
|
|
mGroupList->setGroups(mGroups);
|
|
|
|
bool own_profile = getSelfProfile();
|
|
mCanSeeOnlineIcon->setVisible(false);
|
|
mCantSeeOnlineIcon->setVisible(!own_profile);
|
|
mCanSeeOnMapIcon->setVisible(false);
|
|
mCantSeeOnMapIcon->setVisible(!own_profile);
|
|
mCanEditObjectsIcon->setVisible(false);
|
|
mCantEditObjectsIcon->setVisible(!own_profile);
|
|
|
|
mCanSeeOnlineIcon->setEnabled(false);
|
|
mCantSeeOnlineIcon->setEnabled(false);
|
|
mCanSeeOnMapIcon->setEnabled(false);
|
|
mCantSeeOnMapIcon->setEnabled(false);
|
|
mCanEditObjectsIcon->setEnabled(false);
|
|
mCantEditObjectsIcon->setEnabled(false);
|
|
|
|
childSetVisible("partner_layout", FALSE);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::processProfileProperties(const LLAvatarData* avatar_data)
|
|
{
|
|
const LLRelationship* relationship = LLAvatarTracker::instance().getBuddyInfo(getAvatarId());
|
|
if ((relationship != NULL || gAgent.isGodlike()) && !getSelfProfile())
|
|
{
|
|
// Relies onto friend observer to get information about online status updates.
|
|
// Once SL-17506 gets implemented, condition might need to become:
|
|
// (gAgent.isGodlike() || isRightGrantedFrom || flags & AVATAR_ONLINE)
|
|
processOnlineStatus(relationship != NULL,
|
|
gAgent.isGodlike() || relationship->isRightGrantedFrom(LLRelationship::GRANT_ONLINE_STATUS),
|
|
(avatar_data->flags & AVATAR_ONLINE));
|
|
}
|
|
|
|
fillCommonData(avatar_data);
|
|
|
|
fillPartnerData(avatar_data);
|
|
|
|
fillAccountStatus(avatar_data);
|
|
|
|
setLoaded();
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::processGroupProperties(const LLAvatarGroups* avatar_groups)
|
|
{
|
|
|
|
LLAvatarGroups::group_list_t::const_iterator it = avatar_groups->group_list.begin();
|
|
const LLAvatarGroups::group_list_t::const_iterator it_end = avatar_groups->group_list.end();
|
|
|
|
for (; it_end != it; ++it)
|
|
{
|
|
LLAvatarGroups::LLGroupData group_data = *it;
|
|
mGroups[group_data.group_name] = group_data.group_id;
|
|
}
|
|
|
|
mGroupList->setGroups(mGroups);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::openGroupProfile()
|
|
{
|
|
LLUUID group_id = mGroupList->getSelectedUUID();
|
|
LLGroupActions::show(group_id);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name)
|
|
{
|
|
mAvatarNameCacheConnection.disconnect();
|
|
getChild<LLUICtrl>("display_name")->setValue(av_name.getDisplayName());
|
|
getChild<LLUICtrl>("user_name")->setValue(av_name.getAccountName());
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::setProfileImageUploading(bool loading)
|
|
{
|
|
LLLoadingIndicator* indicator = getChild<LLLoadingIndicator>("image_upload_indicator");
|
|
indicator->setVisible(loading);
|
|
if (loading)
|
|
{
|
|
indicator->start();
|
|
}
|
|
else
|
|
{
|
|
indicator->stop();
|
|
}
|
|
mWaitingForImageUpload = loading;
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::setProfileImageUploaded(const LLUUID &image_asset_id)
|
|
{
|
|
mSecondLifePic->setValue(image_asset_id);
|
|
mImageId = image_asset_id;
|
|
|
|
LLViewerFetchedTexture* imagep = LLViewerTextureManager::getFetchedTexture(image_asset_id);
|
|
if (imagep->getFullHeight())
|
|
{
|
|
onImageLoaded(true, imagep);
|
|
}
|
|
else
|
|
{
|
|
imagep->setLoadedCallback(onImageLoaded,
|
|
MAX_DISCARD_LEVEL,
|
|
FALSE,
|
|
FALSE,
|
|
new LLHandle<LLPanel>(getHandle()),
|
|
NULL,
|
|
FALSE);
|
|
}
|
|
|
|
LLFloater *floater = mFloaterProfileTextureHandle.get();
|
|
if (floater)
|
|
{
|
|
LLFloaterProfileTexture * texture_view = dynamic_cast<LLFloaterProfileTexture*>(floater);
|
|
if (mImageId.notNull())
|
|
{
|
|
texture_view->loadAsset(mImageId);
|
|
}
|
|
else
|
|
{
|
|
texture_view->resetAsset();
|
|
}
|
|
}
|
|
|
|
setProfileImageUploading(false);
|
|
}
|
|
|
|
bool LLPanelProfileSecondLife::hasUnsavedChanges()
|
|
{
|
|
LLFloater *floater = mFloaterPermissionsHandle.get();
|
|
if (floater)
|
|
{
|
|
LLFloaterProfilePermissions* perm = dynamic_cast<LLFloaterProfilePermissions*>(floater);
|
|
if (perm && perm->hasUnsavedChanges())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
// if floater
|
|
return mHasUnsavedDescriptionChanges;
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::commitUnsavedChanges()
|
|
{
|
|
LLFloater *floater = mFloaterPermissionsHandle.get();
|
|
if (floater)
|
|
{
|
|
LLFloaterProfilePermissions* perm = dynamic_cast<LLFloaterProfilePermissions*>(floater);
|
|
if (perm && perm->hasUnsavedChanges())
|
|
{
|
|
perm->onApplyRights();
|
|
}
|
|
}
|
|
if (mHasUnsavedDescriptionChanges)
|
|
{
|
|
onSaveDescriptionChanges();
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::fillCommonData(const LLAvatarData* avatar_data)
|
|
{
|
|
// Refresh avatar id in cache with new info to prevent re-requests
|
|
// and to make sure icons in text will be up to date
|
|
LLAvatarIconIDCache::getInstance()->add(avatar_data->avatar_id, avatar_data->image_id);
|
|
|
|
fillAgeData(avatar_data->born_on);
|
|
|
|
setDescriptionText(avatar_data->about_text);
|
|
|
|
if (avatar_data->image_id.notNull())
|
|
{
|
|
mSecondLifePic->setValue(avatar_data->image_id);
|
|
mImageId = avatar_data->image_id;
|
|
}
|
|
else
|
|
{
|
|
mSecondLifePic->setValue("Generic_Person_Large");
|
|
mImageId = LLUUID::null;
|
|
}
|
|
|
|
// Will be loaded as a LLViewerFetchedTexture::BOOST_UI due to mSecondLifePic
|
|
LLViewerFetchedTexture* imagep = LLViewerTextureManager::getFetchedTexture(avatar_data->image_id);
|
|
if (imagep->getFullHeight())
|
|
{
|
|
onImageLoaded(true, imagep);
|
|
}
|
|
else
|
|
{
|
|
imagep->setLoadedCallback(onImageLoaded,
|
|
MAX_DISCARD_LEVEL,
|
|
FALSE,
|
|
FALSE,
|
|
new LLHandle<LLPanel>(getHandle()),
|
|
NULL,
|
|
FALSE);
|
|
}
|
|
|
|
if (getSelfProfile())
|
|
{
|
|
mAllowPublish = avatar_data->flags & AVATAR_ALLOW_PUBLISH;
|
|
mShowInSearchCombo->setValue((BOOL)mAllowPublish);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::fillPartnerData(const LLAvatarData* avatar_data)
|
|
{
|
|
LLTextBox* partner_text_ctrl = getChild<LLTextBox>("partner_link");
|
|
if (avatar_data->partner_id.notNull())
|
|
{
|
|
childSetVisible("partner_layout", TRUE);
|
|
LLStringUtil::format_map_t args;
|
|
args["[LINK]"] = LLSLURL("agent", avatar_data->partner_id, "inspect").getSLURLString();
|
|
std::string partner_text = getString("partner_text", args);
|
|
partner_text_ctrl->setText(partner_text);
|
|
}
|
|
else
|
|
{
|
|
childSetVisible("partner_layout", FALSE);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::fillAccountStatus(const LLAvatarData* avatar_data)
|
|
{
|
|
LLStringUtil::format_map_t args;
|
|
args["[ACCTTYPE]"] = LLAvatarPropertiesProcessor::accountType(avatar_data);
|
|
args["[PAYMENTINFO]"] = LLAvatarPropertiesProcessor::paymentInfo(avatar_data);
|
|
|
|
std::string caption_text = getString("CaptionTextAcctInfo", args);
|
|
getChild<LLUICtrl>("account_info")->setValue(caption_text);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::fillRightsData()
|
|
{
|
|
if (getSelfProfile())
|
|
{
|
|
return;
|
|
}
|
|
|
|
const LLRelationship* relation = LLAvatarTracker::instance().getBuddyInfo(getAvatarId());
|
|
// If true - we are viewing friend's profile, enable check boxes and set values.
|
|
if (relation)
|
|
{
|
|
S32 rights = relation->getRightsGrantedTo();
|
|
bool can_see_online = LLRelationship::GRANT_ONLINE_STATUS & rights;
|
|
bool can_see_on_map = LLRelationship::GRANT_MAP_LOCATION & rights;
|
|
bool can_edit_objects = LLRelationship::GRANT_MODIFY_OBJECTS & rights;
|
|
|
|
mCanSeeOnlineIcon->setVisible(can_see_online);
|
|
mCantSeeOnlineIcon->setVisible(!can_see_online);
|
|
mCanSeeOnMapIcon->setVisible(can_see_on_map);
|
|
mCantSeeOnMapIcon->setVisible(!can_see_on_map);
|
|
mCanEditObjectsIcon->setVisible(can_edit_objects);
|
|
mCantEditObjectsIcon->setVisible(!can_edit_objects);
|
|
|
|
mCanSeeOnlineIcon->setEnabled(true);
|
|
mCantSeeOnlineIcon->setEnabled(true);
|
|
mCanSeeOnMapIcon->setEnabled(true);
|
|
mCantSeeOnMapIcon->setEnabled(true);
|
|
mCanEditObjectsIcon->setEnabled(true);
|
|
mCantEditObjectsIcon->setEnabled(true);
|
|
}
|
|
else
|
|
{
|
|
mCanSeeOnlineIcon->setVisible(false);
|
|
mCantSeeOnlineIcon->setVisible(false);
|
|
mCanSeeOnMapIcon->setVisible(false);
|
|
mCantSeeOnMapIcon->setVisible(false);
|
|
mCanEditObjectsIcon->setVisible(false);
|
|
mCantEditObjectsIcon->setVisible(false);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::fillAgeData(const LLDate &born_on)
|
|
{
|
|
// Date from server comes already converted to stl timezone,
|
|
// so display it as an UTC + 0
|
|
std::string name_and_date = getString("date_format");
|
|
LLSD args_name;
|
|
args_name["datetime"] = (S32)born_on.secondsSinceEpoch();
|
|
LLStringUtil::format(name_and_date, args_name);
|
|
getChild<LLUICtrl>("sl_birth_date")->setValue(name_and_date);
|
|
|
|
std::string register_date = getString("age_format");
|
|
LLSD args_age;
|
|
args_age["[AGE]"] = LLDateUtil::ageFromDate(born_on, LLDate::now());
|
|
LLStringUtil::format(register_date, args_age);
|
|
getChild<LLUICtrl>("user_age")->setValue(register_date);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onImageLoaded(BOOL success, LLViewerFetchedTexture *imagep)
|
|
{
|
|
LLRect imageRect = mSecondLifePicLayout->getRect();
|
|
if (!success || imagep->getFullWidth() == imagep->getFullHeight())
|
|
{
|
|
mSecondLifePicLayout->reshape(imageRect.getWidth(), imageRect.getWidth());
|
|
}
|
|
else
|
|
{
|
|
// assume 3:4, for sake of firestorm
|
|
mSecondLifePicLayout->reshape(imageRect.getWidth(), imageRect.getWidth() * 3 / 4);
|
|
}
|
|
}
|
|
|
|
//static
|
|
void LLPanelProfileSecondLife::onImageLoaded(BOOL success,
|
|
LLViewerFetchedTexture *src_vi,
|
|
LLImageRaw* src,
|
|
LLImageRaw* aux_src,
|
|
S32 discard_level,
|
|
BOOL final,
|
|
void* userdata)
|
|
{
|
|
if (!userdata) return;
|
|
|
|
LLHandle<LLPanel>* handle = (LLHandle<LLPanel>*)userdata;
|
|
|
|
if (!handle->isDead())
|
|
{
|
|
LLPanelProfileSecondLife* panel = static_cast<LLPanelProfileSecondLife*>(handle->get());
|
|
if (panel)
|
|
{
|
|
panel->onImageLoaded(success, src_vi);
|
|
}
|
|
}
|
|
|
|
if (final || !success)
|
|
{
|
|
delete handle;
|
|
}
|
|
}
|
|
|
|
// virtual, called by LLAvatarTracker
|
|
void LLPanelProfileSecondLife::changed(U32 mask)
|
|
{
|
|
updateOnlineStatus();
|
|
if (mask != LLFriendObserver::ONLINE)
|
|
{
|
|
fillRightsData();
|
|
}
|
|
}
|
|
|
|
// virtual, called by LLVoiceClient
|
|
void LLPanelProfileSecondLife::onChange(EStatusType status, const std::string &channelURI, bool proximal)
|
|
{
|
|
if(status == STATUS_JOINING || status == STATUS_LEFT_CHANNEL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
mVoiceStatus = LLAvatarActions::canCall() && (LLAvatarActions::isFriend(getAvatarId()) ? LLAvatarTracker::instance().isBuddyOnline(getAvatarId()) : TRUE);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::setAvatarId(const LLUUID& avatar_id)
|
|
{
|
|
if (avatar_id.notNull())
|
|
{
|
|
if (getAvatarId().notNull())
|
|
{
|
|
LLAvatarTracker::instance().removeParticularFriendObserver(getAvatarId(), this);
|
|
}
|
|
|
|
LLPanelProfileTab::setAvatarId(avatar_id);
|
|
|
|
if (LLAvatarActions::isFriend(getAvatarId()))
|
|
{
|
|
LLAvatarTracker::instance().addParticularFriendObserver(getAvatarId(), this);
|
|
}
|
|
}
|
|
}
|
|
|
|
// method was disabled according to EXT-2022. Re-enabled & improved according to EXT-3880
|
|
void LLPanelProfileSecondLife::updateOnlineStatus()
|
|
{
|
|
const LLRelationship* relationship = LLAvatarTracker::instance().getBuddyInfo(getAvatarId());
|
|
if (relationship != NULL)
|
|
{
|
|
// For friend let check if he allowed me to see his status
|
|
bool online = relationship->isOnline();
|
|
bool perm_granted = relationship->isRightGrantedFrom(LLRelationship::GRANT_ONLINE_STATUS);
|
|
processOnlineStatus(true, perm_granted, online);
|
|
}
|
|
else
|
|
{
|
|
childSetVisible("frind_layout", false);
|
|
childSetVisible("online_layout", false);
|
|
childSetVisible("offline_layout", false);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::processOnlineStatus(bool is_friend, bool show_online, bool online)
|
|
{
|
|
childSetVisible("frind_layout", is_friend);
|
|
childSetVisible("online_layout", online && show_online);
|
|
childSetVisible("offline_layout", !online && show_online);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::setLoaded()
|
|
{
|
|
LLPanelProfileTab::setLoaded();
|
|
|
|
if (getSelfProfile())
|
|
{
|
|
mShowInSearchCombo->setEnabled(TRUE);
|
|
mDescriptionEdit->setEnabled(TRUE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
class LLProfileImagePicker : public LLFilePickerThread
|
|
{
|
|
public:
|
|
LLProfileImagePicker(EProfileImageType type, LLHandle<LLPanel> *handle);
|
|
~LLProfileImagePicker();
|
|
void notify(const std::vector<std::string>& filenames) override;
|
|
|
|
private:
|
|
LLHandle<LLPanel> *mHandle;
|
|
EProfileImageType mType;
|
|
};
|
|
|
|
LLProfileImagePicker::LLProfileImagePicker(EProfileImageType type, LLHandle<LLPanel> *handle)
|
|
: LLFilePickerThread(LLFilePicker::FFLOAD_IMAGE),
|
|
mHandle(handle),
|
|
mType(type)
|
|
{
|
|
}
|
|
|
|
LLProfileImagePicker::~LLProfileImagePicker()
|
|
{
|
|
delete mHandle;
|
|
}
|
|
|
|
void LLProfileImagePicker::notify(const std::vector<std::string>& filenames)
|
|
{
|
|
if (mHandle->isDead())
|
|
{
|
|
return;
|
|
}
|
|
if (filenames.empty())
|
|
{
|
|
return;
|
|
}
|
|
std::string file_path = filenames[0];
|
|
if (file_path.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// generate a temp texture file for coroutine
|
|
std::string temp_file = gDirUtilp->getTempFilename();
|
|
U32 codec = LLImageBase::getCodecFromExtension(gDirUtilp->getExtension(file_path));
|
|
const S32 MAX_DIM = 256;
|
|
if (!LLViewerTextureList::createUploadFile(file_path, temp_file, codec, MAX_DIM))
|
|
{
|
|
//todo: image not supported notification
|
|
LL_WARNS("AvatarProperties") << "Failed to upload profile image of type " << (S32)PROFILE_IMAGE_SL << ", failed to open image" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_IMAGE_UPLOAD_CAP);
|
|
if (cap_url.empty())
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to upload profile image of type " << (S32)PROFILE_IMAGE_SL << ", no cap found" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
switch (mType)
|
|
{
|
|
case PROFILE_IMAGE_SL:
|
|
{
|
|
LLPanelProfileSecondLife* panel = static_cast<LLPanelProfileSecondLife*>(mHandle->get());
|
|
panel->setProfileImageUploading(true);
|
|
}
|
|
break;
|
|
case PROFILE_IMAGE_FL:
|
|
{
|
|
LLPanelProfileFirstLife* panel = static_cast<LLPanelProfileFirstLife*>(mHandle->get());
|
|
panel->setProfileImageUploading(true);
|
|
}
|
|
break;
|
|
}
|
|
|
|
LLCoros::instance().launch("postAgentUserImageCoro",
|
|
boost::bind(post_profile_image_coro, cap_url, mType, temp_file, mHandle));
|
|
|
|
mHandle = nullptr; // transferred to post_profile_image_coro
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onCommitMenu(const LLSD& userdata)
|
|
{
|
|
const std::string item_name = userdata.asString();
|
|
const LLUUID agent_id = getAvatarId();
|
|
// todo: consider moving this into LLAvatarActions::onCommit(name, id)
|
|
// and making all other flaoters, like people menu do the same
|
|
if (item_name == "im")
|
|
{
|
|
LLAvatarActions::startIM(agent_id);
|
|
}
|
|
else if (item_name == "offer_teleport")
|
|
{
|
|
LLAvatarActions::offerTeleport(agent_id);
|
|
}
|
|
else if (item_name == "request_teleport")
|
|
{
|
|
LLAvatarActions::teleportRequest(agent_id);
|
|
}
|
|
else if (item_name == "voice_call")
|
|
{
|
|
LLAvatarActions::startCall(agent_id);
|
|
}
|
|
else if (item_name == "chat_history")
|
|
{
|
|
LLAvatarActions::viewChatHistory(agent_id);
|
|
}
|
|
else if (item_name == "add_friend")
|
|
{
|
|
LLAvatarActions::requestFriendshipDialog(agent_id);
|
|
}
|
|
else if (item_name == "remove_friend")
|
|
{
|
|
LLAvatarActions::removeFriendDialog(agent_id);
|
|
}
|
|
else if (item_name == "invite_to_group")
|
|
{
|
|
LLAvatarActions::inviteToGroup(agent_id);
|
|
}
|
|
else if (item_name == "can_show_on_map")
|
|
{
|
|
LLAvatarActions::showOnMap(agent_id);
|
|
}
|
|
else if (item_name == "share")
|
|
{
|
|
LLAvatarActions::share(agent_id);
|
|
}
|
|
else if (item_name == "pay")
|
|
{
|
|
LLAvatarActions::pay(agent_id);
|
|
}
|
|
else if (item_name == "toggle_block_agent")
|
|
{
|
|
LLAvatarActions::toggleBlock(agent_id);
|
|
}
|
|
else if (item_name == "copy_user_id")
|
|
{
|
|
LLWString wstr = utf8str_to_wstring(getAvatarId().asString());
|
|
LLClipboard::instance().copyToClipboard(wstr, 0, wstr.size());
|
|
}
|
|
else if (item_name == "agent_permissions")
|
|
{
|
|
onShowAgentPermissionsDialog();
|
|
}
|
|
else if (item_name == "copy_display_name"
|
|
|| item_name == "copy_username")
|
|
{
|
|
LLAvatarName av_name;
|
|
if (!LLAvatarNameCache::get(getAvatarId(), &av_name))
|
|
{
|
|
// shouldn't happen, option is supposed to be invisible while name is fetching
|
|
LL_WARNS() << "Failed to get agent data" << LL_ENDL;
|
|
return;
|
|
}
|
|
LLWString wstr;
|
|
if (item_name == "copy_display_name")
|
|
{
|
|
wstr = utf8str_to_wstring(av_name.getDisplayName(true));
|
|
}
|
|
else if (item_name == "copy_username")
|
|
{
|
|
wstr = utf8str_to_wstring(av_name.getUserName());
|
|
}
|
|
LLClipboard::instance().copyToClipboard(wstr, 0, wstr.size());
|
|
}
|
|
else if (item_name == "edit_display_name")
|
|
{
|
|
LLAvatarNameCache::get(getAvatarId(), boost::bind(&LLPanelProfileSecondLife::onAvatarNameCacheSetName, this, _1, _2));
|
|
LLFirstUse::setDisplayName(false);
|
|
}
|
|
else if (item_name == "edit_partner")
|
|
{
|
|
std::string url = "https://[GRID]/my/account/partners.php";
|
|
LLSD subs;
|
|
url = LLWeb::expandURLSubstitutions(url, subs);
|
|
LLUrlAction::openURL(url);
|
|
}
|
|
else if (item_name == "upload_photo")
|
|
{
|
|
(new LLProfileImagePicker(PROFILE_IMAGE_SL, new LLHandle<LLPanel>(getHandle())))->getFile();
|
|
|
|
LLFloater* floaterp = mFloaterTexturePickerHandle.get();
|
|
if (floaterp)
|
|
{
|
|
floaterp->closeFloater();
|
|
}
|
|
}
|
|
else if (item_name == "change_photo")
|
|
{
|
|
onShowTexturePicker();
|
|
}
|
|
else if (item_name == "remove_photo")
|
|
{
|
|
onCommitProfileImage(LLUUID::null);
|
|
|
|
LLFloater* floaterp = mFloaterTexturePickerHandle.get();
|
|
if (floaterp)
|
|
{
|
|
floaterp->closeFloater();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool LLPanelProfileSecondLife::onEnableMenu(const LLSD& userdata)
|
|
{
|
|
const std::string item_name = userdata.asString();
|
|
const LLUUID agent_id = getAvatarId();
|
|
if (item_name == "offer_teleport" || item_name == "request_teleport")
|
|
{
|
|
return LLAvatarActions::canOfferTeleport(agent_id);
|
|
}
|
|
else if (item_name == "voice_call")
|
|
{
|
|
return mVoiceStatus;
|
|
}
|
|
else if (item_name == "chat_history")
|
|
{
|
|
return LLLogChat::isTranscriptExist(agent_id);
|
|
}
|
|
else if (item_name == "add_friend")
|
|
{
|
|
return !LLAvatarActions::isFriend(agent_id);
|
|
}
|
|
else if (item_name == "remove_friend")
|
|
{
|
|
return LLAvatarActions::isFriend(agent_id);
|
|
}
|
|
else if (item_name == "can_show_on_map")
|
|
{
|
|
return (LLAvatarTracker::instance().isBuddyOnline(agent_id) && is_agent_mappable(agent_id))
|
|
|| gAgent.isGodlike();
|
|
}
|
|
else if (item_name == "toggle_block_agent")
|
|
{
|
|
return LLAvatarActions::canBlock(agent_id);
|
|
}
|
|
else if (item_name == "agent_permissions")
|
|
{
|
|
return LLAvatarActions::isFriend(agent_id);
|
|
}
|
|
else if (item_name == "copy_display_name"
|
|
|| item_name == "copy_username")
|
|
{
|
|
return !mAvatarNameCacheConnection.connected();
|
|
}
|
|
else if (item_name == "upload_photo"
|
|
|| item_name == "change_photo")
|
|
{
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_IMAGE_UPLOAD_CAP);
|
|
return !cap_url.empty() && !mWaitingForImageUpload && getIsLoaded();
|
|
}
|
|
else if (item_name == "remove_photo")
|
|
{
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
return mImageId.notNull() && !cap_url.empty() && !mWaitingForImageUpload && getIsLoaded();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LLPanelProfileSecondLife::onCheckMenu(const LLSD& userdata)
|
|
{
|
|
const std::string item_name = userdata.asString();
|
|
const LLUUID agent_id = getAvatarId();
|
|
if (item_name == "toggle_block_agent")
|
|
{
|
|
return LLAvatarActions::isBlocked(agent_id);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onAvatarNameCacheSetName(const LLUUID& agent_id, const LLAvatarName& av_name)
|
|
{
|
|
if (av_name.getDisplayName().empty())
|
|
{
|
|
// something is wrong, tell user to try again later
|
|
LLNotificationsUtil::add("SetDisplayNameFailedGeneric");
|
|
return;
|
|
}
|
|
|
|
LL_INFOS("LegacyProfile") << "name-change now " << LLDate::now() << " next_update "
|
|
<< LLDate(av_name.mNextUpdate) << LL_ENDL;
|
|
F64 now_secs = LLDate::now().secondsSinceEpoch();
|
|
|
|
if (now_secs < av_name.mNextUpdate)
|
|
{
|
|
// if the update time is more than a year in the future, it means updates have been blocked
|
|
// show a more general message
|
|
static const S32 YEAR = 60*60*24*365;
|
|
if (now_secs + YEAR < av_name.mNextUpdate)
|
|
{
|
|
LLNotificationsUtil::add("SetDisplayNameBlocked");
|
|
return;
|
|
}
|
|
}
|
|
|
|
LLFloaterReg::showInstance("display_name");
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::setDescriptionText(const std::string &text)
|
|
{
|
|
mSaveDescriptionChanges->setEnabled(FALSE);
|
|
mDiscardDescriptionChanges->setEnabled(FALSE);
|
|
mHasUnsavedDescriptionChanges = false;
|
|
|
|
mDescriptionText = text;
|
|
mDescriptionEdit->setValue(mDescriptionText);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onSetDescriptionDirty()
|
|
{
|
|
mSaveDescriptionChanges->setEnabled(TRUE);
|
|
mDiscardDescriptionChanges->setEnabled(TRUE);
|
|
mHasUnsavedDescriptionChanges = true;
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onShowInSearchCallback()
|
|
{
|
|
S32 value = mShowInSearchCombo->getValue().asInteger();
|
|
if (mAllowPublish == (bool)value)
|
|
{
|
|
return;
|
|
}
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
mAllowPublish = value;
|
|
LLSD data;
|
|
data["allow_publish"] = mAllowPublish;
|
|
LLCoros::instance().launch("putAgentUserInfoCoro",
|
|
boost::bind(put_avatar_properties_coro, cap_url, getAvatarId(), data));
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to update profile data, no cap found" << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onSaveDescriptionChanges()
|
|
{
|
|
mDescriptionText = mDescriptionEdit->getValue().asString();
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLCoros::instance().launch("putAgentUserInfoCoro",
|
|
boost::bind(put_avatar_properties_coro, cap_url, getAvatarId(), LLSD().with("sl_about_text", mDescriptionText)));
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to update profile data, no cap found" << LL_ENDL;
|
|
}
|
|
|
|
mSaveDescriptionChanges->setEnabled(FALSE);
|
|
mDiscardDescriptionChanges->setEnabled(FALSE);
|
|
mHasUnsavedDescriptionChanges = false;
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onDiscardDescriptionChanges()
|
|
{
|
|
setDescriptionText(mDescriptionText);
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onShowAgentPermissionsDialog()
|
|
{
|
|
LLFloater *floater = mFloaterPermissionsHandle.get();
|
|
if (!floater)
|
|
{
|
|
LLFloater* parent_floater = gFloaterView->getParentFloater(this);
|
|
if (parent_floater)
|
|
{
|
|
LLFloaterProfilePermissions * perms = new LLFloaterProfilePermissions(parent_floater, getAvatarId());
|
|
mFloaterPermissionsHandle = perms->getHandle();
|
|
perms->openFloater();
|
|
perms->setVisibleAndFrontmost(TRUE);
|
|
|
|
parent_floater->addDependentFloater(mFloaterPermissionsHandle);
|
|
}
|
|
}
|
|
else // already open
|
|
{
|
|
floater->setMinimized(FALSE);
|
|
floater->setVisibleAndFrontmost(TRUE);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onShowAgentProfileTexture()
|
|
{
|
|
if (!getIsLoaded())
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLFloater *floater = mFloaterProfileTextureHandle.get();
|
|
if (!floater)
|
|
{
|
|
LLFloater* parent_floater = gFloaterView->getParentFloater(this);
|
|
if (parent_floater)
|
|
{
|
|
LLFloaterProfileTexture * texture_view = new LLFloaterProfileTexture(parent_floater);
|
|
mFloaterProfileTextureHandle = texture_view->getHandle();
|
|
if (mImageId.notNull())
|
|
{
|
|
texture_view->loadAsset(mImageId);
|
|
}
|
|
else
|
|
{
|
|
texture_view->resetAsset();
|
|
}
|
|
texture_view->openFloater();
|
|
texture_view->setVisibleAndFrontmost(TRUE);
|
|
|
|
parent_floater->addDependentFloater(mFloaterProfileTextureHandle);
|
|
}
|
|
}
|
|
else // already open
|
|
{
|
|
LLFloaterProfileTexture * texture_view = dynamic_cast<LLFloaterProfileTexture*>(floater);
|
|
texture_view->setMinimized(FALSE);
|
|
texture_view->setVisibleAndFrontmost(TRUE);
|
|
if (mImageId.notNull())
|
|
{
|
|
texture_view->loadAsset(mImageId);
|
|
}
|
|
else
|
|
{
|
|
texture_view->resetAsset();
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onShowTexturePicker()
|
|
{
|
|
LLFloater* floaterp = mFloaterTexturePickerHandle.get();
|
|
|
|
// Show the dialog
|
|
if (!floaterp)
|
|
{
|
|
LLFloater* parent_floater = gFloaterView->getParentFloater(this);
|
|
if (parent_floater)
|
|
{
|
|
// because inventory construction is somewhat slow
|
|
getWindow()->setCursor(UI_CURSOR_WAIT);
|
|
LLFloaterTexturePicker* texture_floaterp = new LLFloaterTexturePicker(
|
|
this,
|
|
mImageId,
|
|
LLUUID::null,
|
|
mImageId,
|
|
FALSE,
|
|
FALSE,
|
|
"SELECT PHOTO",
|
|
PERM_NONE,
|
|
PERM_NONE,
|
|
PERM_NONE,
|
|
FALSE,
|
|
NULL);
|
|
|
|
mFloaterTexturePickerHandle = texture_floaterp->getHandle();
|
|
|
|
texture_floaterp->setOnFloaterCommitCallback([this](LLTextureCtrl::ETexturePickOp op, LLUUID id)
|
|
{
|
|
if (op == LLTextureCtrl::TEXTURE_SELECT)
|
|
{
|
|
LLUUID image_asset_id;
|
|
LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterTexturePickerHandle.get();
|
|
if (floaterp)
|
|
{
|
|
if (id.notNull())
|
|
{
|
|
image_asset_id = id;
|
|
}
|
|
else
|
|
{
|
|
image_asset_id = floaterp->getAssetID();
|
|
}
|
|
}
|
|
|
|
onCommitProfileImage(image_asset_id);
|
|
}
|
|
});
|
|
texture_floaterp->setLocalTextureEnabled(FALSE);
|
|
texture_floaterp->setBakeTextureEnabled(FALSE);
|
|
texture_floaterp->setCanApply(false, true);
|
|
|
|
parent_floater->addDependentFloater(mFloaterTexturePickerHandle);
|
|
|
|
texture_floaterp->openFloater();
|
|
texture_floaterp->setFocus(TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
floaterp->setMinimized(FALSE);
|
|
floaterp->setVisibleAndFrontmost(TRUE);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileSecondLife::onCommitProfileImage(const LLUUID& id)
|
|
{
|
|
if (mImageId == id)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLSD params;
|
|
params["sl_image_id"] = id;
|
|
LLCoros::instance().launch("putAgentUserInfoCoro",
|
|
boost::bind(put_avatar_properties_coro, cap_url, getAvatarId(), params));
|
|
|
|
mImageId = id;
|
|
if (mImageId == LLUUID::null)
|
|
{
|
|
mSecondLifePic->setValue("Generic_Person_Large");
|
|
}
|
|
else
|
|
{
|
|
mSecondLifePic->setValue(mImageId);
|
|
}
|
|
|
|
LLFloater *floater = mFloaterProfileTextureHandle.get();
|
|
if (floater)
|
|
{
|
|
LLFloaterProfileTexture * texture_view = dynamic_cast<LLFloaterProfileTexture*>(floater);
|
|
if (mImageId == LLUUID::null)
|
|
{
|
|
texture_view->resetAsset();
|
|
}
|
|
else
|
|
{
|
|
texture_view->loadAsset(mImageId);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to update profile data, no cap found" << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// LLPanelProfileWeb
|
|
|
|
LLPanelProfileWeb::LLPanelProfileWeb()
|
|
: LLPanelProfileTab()
|
|
, mWebBrowser(NULL)
|
|
, mAvatarNameCacheConnection()
|
|
{
|
|
}
|
|
|
|
LLPanelProfileWeb::~LLPanelProfileWeb()
|
|
{
|
|
if (mAvatarNameCacheConnection.connected())
|
|
{
|
|
mAvatarNameCacheConnection.disconnect();
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileWeb::onOpen(const LLSD& key)
|
|
{
|
|
LLPanelProfileTab::onOpen(key);
|
|
|
|
resetData();
|
|
|
|
mAvatarNameCacheConnection = LLAvatarNameCache::get(getAvatarId(), boost::bind(&LLPanelProfileWeb::onAvatarNameCache, this, _1, _2));
|
|
}
|
|
|
|
BOOL LLPanelProfileWeb::postBuild()
|
|
{
|
|
mWebBrowser = getChild<LLMediaCtrl>("profile_html");
|
|
mWebBrowser->addObserver(this);
|
|
mWebBrowser->setHomePageUrl("about:blank");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void LLPanelProfileWeb::resetData()
|
|
{
|
|
mWebBrowser->navigateHome();
|
|
}
|
|
|
|
void LLPanelProfileWeb::updateData()
|
|
{
|
|
LLUUID avatar_id = getAvatarId();
|
|
if (!getStarted() && avatar_id.notNull() && !mURLWebProfile.empty())
|
|
{
|
|
setIsLoading();
|
|
|
|
mWebBrowser->setVisible(TRUE);
|
|
mPerformanceTimer.start();
|
|
mWebBrowser->navigateTo(mURLWebProfile, HTTP_CONTENT_TEXT_HTML);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileWeb::onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name)
|
|
{
|
|
mAvatarNameCacheConnection.disconnect();
|
|
|
|
std::string username = av_name.getAccountName();
|
|
if (username.empty())
|
|
{
|
|
username = LLCacheName::buildUsername(av_name.getDisplayName());
|
|
}
|
|
else
|
|
{
|
|
LLStringUtil::replaceChar(username, ' ', '.');
|
|
}
|
|
|
|
mURLWebProfile = getProfileURL(username, true);
|
|
if (mURLWebProfile.empty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//if the tab was opened before name was resolved, load the panel now
|
|
updateData();
|
|
}
|
|
|
|
void LLPanelProfileWeb::onCommitLoad(LLUICtrl* ctrl)
|
|
{
|
|
if (!mURLHome.empty())
|
|
{
|
|
LLSD::String valstr = ctrl->getValue().asString();
|
|
if (valstr.empty())
|
|
{
|
|
mWebBrowser->setVisible(TRUE);
|
|
mPerformanceTimer.start();
|
|
mWebBrowser->navigateTo( mURLHome, HTTP_CONTENT_TEXT_HTML );
|
|
}
|
|
else if (valstr == "popout")
|
|
{
|
|
// open in viewer's browser, new window
|
|
LLWeb::loadURLInternal(mURLHome);
|
|
}
|
|
else if (valstr == "external")
|
|
{
|
|
// open in external browser
|
|
LLWeb::loadURLExternal(mURLHome);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileWeb::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
|
|
{
|
|
switch(event)
|
|
{
|
|
case MEDIA_EVENT_STATUS_TEXT_CHANGED:
|
|
childSetValue("status_text", LLSD( self->getStatusText() ) );
|
|
break;
|
|
|
|
case MEDIA_EVENT_NAVIGATE_BEGIN:
|
|
{
|
|
if (mFirstNavigate)
|
|
{
|
|
mFirstNavigate = false;
|
|
}
|
|
else
|
|
{
|
|
mPerformanceTimer.start();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MEDIA_EVENT_NAVIGATE_COMPLETE:
|
|
{
|
|
LLStringUtil::format_map_t args;
|
|
args["[TIME]"] = llformat("%.2f", mPerformanceTimer.getElapsedTimeF32());
|
|
childSetValue("status_text", LLSD( getString("LoadTime", args)) );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Having a default case makes the compiler happy.
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
LLPanelProfileFirstLife::LLPanelProfileFirstLife()
|
|
: LLPanelProfileTab()
|
|
, mHasUnsavedChanges(false)
|
|
{
|
|
}
|
|
|
|
LLPanelProfileFirstLife::~LLPanelProfileFirstLife()
|
|
{
|
|
}
|
|
|
|
BOOL LLPanelProfileFirstLife::postBuild()
|
|
{
|
|
mDescriptionEdit = getChild<LLTextEditor>("fl_description_edit");
|
|
mPicture = getChild<LLIconCtrl>("real_world_pic");
|
|
|
|
mUploadPhoto = getChild<LLButton>("fl_upload_image");
|
|
mChangePhoto = getChild<LLButton>("fl_change_image");
|
|
mRemovePhoto = getChild<LLButton>("fl_remove_image");
|
|
mSaveChanges = getChild<LLButton>("fl_save_changes");
|
|
mDiscardChanges = getChild<LLButton>("fl_discard_changes");
|
|
|
|
mUploadPhoto->setCommitCallback([this](LLUICtrl*, void*) { onUploadPhoto(); }, nullptr);
|
|
mChangePhoto->setCommitCallback([this](LLUICtrl*, void*) { onChangePhoto(); }, nullptr);
|
|
mRemovePhoto->setCommitCallback([this](LLUICtrl*, void*) { onRemovePhoto(); }, nullptr);
|
|
mSaveChanges->setCommitCallback([this](LLUICtrl*, void*) { onSaveDescriptionChanges(); }, nullptr);
|
|
mDiscardChanges->setCommitCallback([this](LLUICtrl*, void*) { onDiscardDescriptionChanges(); }, nullptr);
|
|
mDescriptionEdit->setKeystrokeCallback([this](LLTextEditor* caller) { onSetDescriptionDirty(); });
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onOpen(const LLSD& key)
|
|
{
|
|
LLPanelProfileTab::onOpen(key);
|
|
|
|
if (!getSelfProfile())
|
|
{
|
|
// Otherwise as the only focusable element it will be selected
|
|
mDescriptionEdit->setTabStop(FALSE);
|
|
}
|
|
|
|
resetData();
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::setProfileImageUploading(bool loading)
|
|
{
|
|
mUploadPhoto->setEnabled(!loading);
|
|
mChangePhoto->setEnabled(!loading);
|
|
mRemovePhoto->setEnabled(!loading && mImageId.notNull());
|
|
|
|
LLLoadingIndicator* indicator = getChild<LLLoadingIndicator>("image_upload_indicator");
|
|
indicator->setVisible(loading);
|
|
if (loading)
|
|
{
|
|
indicator->start();
|
|
}
|
|
else
|
|
{
|
|
indicator->stop();
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::setProfileImageUploaded(const LLUUID &image_asset_id)
|
|
{
|
|
mPicture->setValue(image_asset_id);
|
|
mImageId = image_asset_id;
|
|
setProfileImageUploading(false);
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::commitUnsavedChanges()
|
|
{
|
|
if (mHasUnsavedChanges)
|
|
{
|
|
onSaveDescriptionChanges();
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onUploadPhoto()
|
|
{
|
|
(new LLProfileImagePicker(PROFILE_IMAGE_FL, new LLHandle<LLPanel>(getHandle())))->getFile();
|
|
|
|
LLFloater* floaterp = mFloaterTexturePickerHandle.get();
|
|
if (floaterp)
|
|
{
|
|
floaterp->closeFloater();
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onChangePhoto()
|
|
{
|
|
LLFloater* floaterp = mFloaterTexturePickerHandle.get();
|
|
|
|
// Show the dialog
|
|
if (!floaterp)
|
|
{
|
|
LLFloater* parent_floater = gFloaterView->getParentFloater(this);
|
|
if (parent_floater)
|
|
{
|
|
// because inventory construction is somewhat slow
|
|
getWindow()->setCursor(UI_CURSOR_WAIT);
|
|
LLFloaterTexturePicker* texture_floaterp = new LLFloaterTexturePicker(
|
|
this,
|
|
mImageId,
|
|
LLUUID::null,
|
|
mImageId,
|
|
FALSE,
|
|
FALSE,
|
|
"SELECT PHOTO",
|
|
PERM_NONE,
|
|
PERM_NONE,
|
|
PERM_NONE,
|
|
FALSE,
|
|
NULL);
|
|
|
|
mFloaterTexturePickerHandle = texture_floaterp->getHandle();
|
|
|
|
texture_floaterp->setOnFloaterCommitCallback([this](LLTextureCtrl::ETexturePickOp op, LLUUID id)
|
|
{
|
|
if (op == LLTextureCtrl::TEXTURE_SELECT)
|
|
{
|
|
LLUUID image_asset_id;
|
|
LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterTexturePickerHandle.get();
|
|
if (floaterp)
|
|
{
|
|
if (id.notNull())
|
|
{
|
|
image_asset_id = id;
|
|
}
|
|
else
|
|
{
|
|
image_asset_id = floaterp->getAssetID();
|
|
}
|
|
}
|
|
|
|
onCommitPhoto(image_asset_id);
|
|
}
|
|
});
|
|
texture_floaterp->setLocalTextureEnabled(FALSE);
|
|
texture_floaterp->setCanApply(false, true);
|
|
|
|
parent_floater->addDependentFloater(mFloaterTexturePickerHandle);
|
|
|
|
texture_floaterp->openFloater();
|
|
texture_floaterp->setFocus(TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
floaterp->setMinimized(FALSE);
|
|
floaterp->setVisibleAndFrontmost(TRUE);
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onRemovePhoto()
|
|
{
|
|
onCommitPhoto(LLUUID::null);
|
|
|
|
LLFloater* floaterp = mFloaterTexturePickerHandle.get();
|
|
if (floaterp)
|
|
{
|
|
floaterp->closeFloater();
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onCommitPhoto(const LLUUID& id)
|
|
{
|
|
if (mImageId == id)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLSD params;
|
|
params["fl_image_id"] = id;
|
|
LLCoros::instance().launch("putAgentUserInfoCoro",
|
|
boost::bind(put_avatar_properties_coro, cap_url, getAvatarId(), params));
|
|
|
|
mImageId = id;
|
|
if (mImageId.notNull())
|
|
{
|
|
mPicture->setValue(mImageId);
|
|
}
|
|
else
|
|
{
|
|
mPicture->setValue("Generic_Person_Large");
|
|
}
|
|
|
|
mRemovePhoto->setEnabled(mImageId.notNull());
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to update profile data, no cap found" << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::setDescriptionText(const std::string &text)
|
|
{
|
|
mSaveChanges->setEnabled(FALSE);
|
|
mDiscardChanges->setEnabled(FALSE);
|
|
mHasUnsavedChanges = false;
|
|
|
|
mCurrentDescription = text;
|
|
mDescriptionEdit->setValue(mCurrentDescription);
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onSetDescriptionDirty()
|
|
{
|
|
mSaveChanges->setEnabled(TRUE);
|
|
mDiscardChanges->setEnabled(TRUE);
|
|
mHasUnsavedChanges = true;
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onSaveDescriptionChanges()
|
|
{
|
|
mCurrentDescription = mDescriptionEdit->getValue().asString();
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLCoros::instance().launch("putAgentUserInfoCoro",
|
|
boost::bind(put_avatar_properties_coro, cap_url, getAvatarId(), LLSD().with("fl_about_text", mCurrentDescription)));
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to update profile data, no cap found" << LL_ENDL;
|
|
}
|
|
|
|
mSaveChanges->setEnabled(FALSE);
|
|
mDiscardChanges->setEnabled(FALSE);
|
|
mHasUnsavedChanges = false;
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::onDiscardDescriptionChanges()
|
|
{
|
|
setDescriptionText(mCurrentDescription);
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::processProperties(const LLAvatarData* avatar_data)
|
|
{
|
|
setDescriptionText(avatar_data->fl_about_text);
|
|
|
|
mImageId = avatar_data->fl_image_id;
|
|
|
|
if (mImageId.notNull())
|
|
{
|
|
mPicture->setValue(mImageId);
|
|
}
|
|
else
|
|
{
|
|
mPicture->setValue("Generic_Person_Large");
|
|
}
|
|
|
|
setLoaded();
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::resetData()
|
|
{
|
|
setDescriptionText(std::string());
|
|
mPicture->setValue("Generic_Person_Large");
|
|
mImageId = LLUUID::null;
|
|
|
|
mUploadPhoto->setVisible(getSelfProfile());
|
|
mChangePhoto->setVisible(getSelfProfile());
|
|
mRemovePhoto->setVisible(getSelfProfile());
|
|
mSaveChanges->setVisible(getSelfProfile());
|
|
mDiscardChanges->setVisible(getSelfProfile());
|
|
}
|
|
|
|
void LLPanelProfileFirstLife::setLoaded()
|
|
{
|
|
LLPanelProfileTab::setLoaded();
|
|
|
|
if (getSelfProfile())
|
|
{
|
|
mDescriptionEdit->setEnabled(TRUE);
|
|
mPicture->setEnabled(TRUE);
|
|
mRemovePhoto->setEnabled(mImageId.notNull());
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
LLPanelProfileNotes::LLPanelProfileNotes()
|
|
: LLPanelProfileTab()
|
|
, mHasUnsavedChanges(false)
|
|
{
|
|
|
|
}
|
|
|
|
LLPanelProfileNotes::~LLPanelProfileNotes()
|
|
{
|
|
}
|
|
|
|
void LLPanelProfileNotes::updateData()
|
|
{
|
|
LLUUID avatar_id = getAvatarId();
|
|
if (!getStarted() && avatar_id.notNull())
|
|
{
|
|
setIsLoading();
|
|
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLCoros::instance().launch("requestAgentUserInfoCoro",
|
|
boost::bind(request_avatar_properties_coro, cap_url, avatar_id));
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLPanelProfileNotes::commitUnsavedChanges()
|
|
{
|
|
if (mHasUnsavedChanges)
|
|
{
|
|
onSaveNotesChanges();
|
|
}
|
|
}
|
|
|
|
BOOL LLPanelProfileNotes::postBuild()
|
|
{
|
|
mNotesEditor = getChild<LLTextEditor>("notes_edit");
|
|
mSaveChanges = getChild<LLButton>("notes_save_changes");
|
|
mDiscardChanges = getChild<LLButton>("notes_discard_changes");
|
|
|
|
mSaveChanges->setCommitCallback([this](LLUICtrl*, void*) { onSaveNotesChanges(); }, nullptr);
|
|
mDiscardChanges->setCommitCallback([this](LLUICtrl*, void*) { onDiscardNotesChanges(); }, nullptr);
|
|
mNotesEditor->setKeystrokeCallback([this](LLTextEditor* caller) { onSetNotesDirty(); });
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void LLPanelProfileNotes::onOpen(const LLSD& key)
|
|
{
|
|
LLPanelProfileTab::onOpen(key);
|
|
|
|
resetData();
|
|
}
|
|
|
|
void LLPanelProfileNotes::setNotesText(const std::string &text)
|
|
{
|
|
mSaveChanges->setEnabled(FALSE);
|
|
mDiscardChanges->setEnabled(FALSE);
|
|
mHasUnsavedChanges = false;
|
|
|
|
mCurrentNotes = text;
|
|
mNotesEditor->setValue(mCurrentNotes);
|
|
}
|
|
|
|
void LLPanelProfileNotes::onSetNotesDirty()
|
|
{
|
|
mSaveChanges->setEnabled(TRUE);
|
|
mDiscardChanges->setEnabled(TRUE);
|
|
mHasUnsavedChanges = true;
|
|
}
|
|
|
|
void LLPanelProfileNotes::onSaveNotesChanges()
|
|
{
|
|
mCurrentNotes = mNotesEditor->getValue().asString();
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLCoros::instance().launch("putAgentUserInfoCoro",
|
|
boost::bind(put_avatar_properties_coro, cap_url, getAvatarId(), LLSD().with("notes", mCurrentNotes)));
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AvatarProperties") << "Failed to update profile data, no cap found" << LL_ENDL;
|
|
}
|
|
|
|
mSaveChanges->setEnabled(FALSE);
|
|
mDiscardChanges->setEnabled(FALSE);
|
|
mHasUnsavedChanges = false;
|
|
}
|
|
|
|
void LLPanelProfileNotes::onDiscardNotesChanges()
|
|
{
|
|
setNotesText(mCurrentNotes);
|
|
}
|
|
|
|
void LLPanelProfileNotes::processProperties(LLAvatarNotes* avatar_notes)
|
|
{
|
|
setNotesText(avatar_notes->notes);
|
|
mNotesEditor->setEnabled(TRUE);
|
|
setLoaded();
|
|
}
|
|
|
|
void LLPanelProfileNotes::resetData()
|
|
{
|
|
resetLoading();
|
|
setNotesText(std::string());
|
|
}
|
|
|
|
void LLPanelProfileNotes::setAvatarId(const LLUUID& avatar_id)
|
|
{
|
|
if (avatar_id.notNull())
|
|
{
|
|
LLPanelProfileTab::setAvatarId(avatar_id);
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// LLPanelProfile
|
|
|
|
LLPanelProfile::LLPanelProfile()
|
|
: LLPanelProfileTab()
|
|
{
|
|
}
|
|
|
|
LLPanelProfile::~LLPanelProfile()
|
|
{
|
|
}
|
|
|
|
BOOL LLPanelProfile::postBuild()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
void LLPanelProfile::onTabChange()
|
|
{
|
|
LLPanelProfileTab* active_panel = dynamic_cast<LLPanelProfileTab*>(mTabContainer->getCurrentPanel());
|
|
if (active_panel)
|
|
{
|
|
active_panel->updateData();
|
|
}
|
|
}
|
|
|
|
void LLPanelProfile::onOpen(const LLSD& key)
|
|
{
|
|
LLUUID avatar_id = key["id"].asUUID();
|
|
|
|
// Don't reload the same profile
|
|
if (getAvatarId() == avatar_id)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLPanelProfileTab::onOpen(avatar_id);
|
|
|
|
mTabContainer = getChild<LLTabContainer>("panel_profile_tabs");
|
|
mPanelSecondlife = findChild<LLPanelProfileSecondLife>(PANEL_SECONDLIFE);
|
|
mPanelWeb = findChild<LLPanelProfileWeb>(PANEL_WEB);
|
|
mPanelPicks = findChild<LLPanelProfilePicks>(PANEL_PICKS);
|
|
mPanelClassifieds = findChild<LLPanelProfileClassifieds>(PANEL_CLASSIFIEDS);
|
|
mPanelFirstlife = findChild<LLPanelProfileFirstLife>(PANEL_FIRSTLIFE);
|
|
mPanelNotes = findChild<LLPanelProfileNotes>(PANEL_NOTES);
|
|
|
|
mPanelSecondlife->onOpen(avatar_id);
|
|
mPanelWeb->onOpen(avatar_id);
|
|
mPanelPicks->onOpen(avatar_id);
|
|
mPanelClassifieds->onOpen(avatar_id);
|
|
mPanelFirstlife->onOpen(avatar_id);
|
|
mPanelNotes->onOpen(avatar_id);
|
|
|
|
// Always request the base profile info
|
|
resetLoading();
|
|
updateData();
|
|
|
|
// Some tabs only request data when opened
|
|
mTabContainer->setCommitCallback(boost::bind(&LLPanelProfile::onTabChange, this));
|
|
}
|
|
|
|
void LLPanelProfile::updateData()
|
|
{
|
|
LLUUID avatar_id = getAvatarId();
|
|
// Todo: getIsloading functionality needs to be expanded to
|
|
// include 'inited' or 'data_provided' state to not rerequest
|
|
if (!getStarted() && avatar_id.notNull())
|
|
{
|
|
setIsLoading();
|
|
|
|
mPanelSecondlife->setIsLoading();
|
|
mPanelPicks->setIsLoading();
|
|
mPanelFirstlife->setIsLoading();
|
|
mPanelNotes->setIsLoading();
|
|
|
|
std::string cap_url = gAgent.getRegionCapability(PROFILE_PROPERTIES_CAP);
|
|
if (!cap_url.empty())
|
|
{
|
|
LLCoros::instance().launch("requestAgentUserInfoCoro",
|
|
boost::bind(request_avatar_properties_coro, cap_url, avatar_id));
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLPanelProfile::refreshName()
|
|
{
|
|
mPanelSecondlife->refreshName();
|
|
}
|
|
|
|
void LLPanelProfile::createPick(const LLPickData &data)
|
|
{
|
|
mTabContainer->selectTabPanel(mPanelPicks);
|
|
mPanelPicks->createPick(data);
|
|
}
|
|
|
|
void LLPanelProfile::showPick(const LLUUID& pick_id)
|
|
{
|
|
if (pick_id.notNull())
|
|
{
|
|
mPanelPicks->selectPick(pick_id);
|
|
}
|
|
mTabContainer->selectTabPanel(mPanelPicks);
|
|
}
|
|
|
|
bool LLPanelProfile::isPickTabSelected()
|
|
{
|
|
return (mTabContainer->getCurrentPanel() == mPanelPicks);
|
|
}
|
|
|
|
bool LLPanelProfile::isNotesTabSelected()
|
|
{
|
|
return (mTabContainer->getCurrentPanel() == mPanelNotes);
|
|
}
|
|
|
|
bool LLPanelProfile::hasUnsavedChanges()
|
|
{
|
|
return mPanelSecondlife->hasUnsavedChanges()
|
|
|| mPanelPicks->hasUnsavedChanges()
|
|
|| mPanelClassifieds->hasUnsavedChanges()
|
|
|| mPanelFirstlife->hasUnsavedChanges()
|
|
|| mPanelNotes->hasUnsavedChanges();
|
|
}
|
|
|
|
bool LLPanelProfile::hasUnpublishedClassifieds()
|
|
{
|
|
return mPanelClassifieds->hasNewClassifieds();
|
|
}
|
|
|
|
void LLPanelProfile::commitUnsavedChanges()
|
|
{
|
|
mPanelSecondlife->commitUnsavedChanges();
|
|
mPanelPicks->commitUnsavedChanges();
|
|
mPanelClassifieds->commitUnsavedChanges();
|
|
mPanelFirstlife->commitUnsavedChanges();
|
|
mPanelNotes->commitUnsavedChanges();
|
|
}
|
|
|
|
void LLPanelProfile::showClassified(const LLUUID& classified_id, bool edit)
|
|
{
|
|
if (classified_id.notNull())
|
|
{
|
|
mPanelClassifieds->selectClassified(classified_id, edit);
|
|
}
|
|
mTabContainer->selectTabPanel(mPanelClassifieds);
|
|
}
|
|
|
|
void LLPanelProfile::createClassified()
|
|
{
|
|
mPanelClassifieds->createClassified();
|
|
mTabContainer->selectTabPanel(mPanelClassifieds);
|
|
}
|
|
|