953 lines
27 KiB
C++
953 lines
27 KiB
C++
/**
|
|
* @file fsfloaterplacedetails.cpp
|
|
* @brief Class for the place details floater in Firestorm
|
|
*
|
|
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
|
|
* Phoenix Firestorm Viewer Source Code
|
|
* Copyright (c) 2012 Ansariel Hiller @ Second Life
|
|
*
|
|
* 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
|
|
*
|
|
* The Phoenix Firestorm Project, Inc., 1831 Oakwood Drive, Fairmont, Minnesota 56031-3225 USA
|
|
* http://www.firestormviewer.org
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "fsfloaterplacedetails.h"
|
|
|
|
#include "llbutton.h"
|
|
#include "llcombobox.h"
|
|
#include "lllineeditor.h"
|
|
#include "llmenubutton.h"
|
|
#include "lltexteditor.h"
|
|
#include "lltoggleablemenu.h"
|
|
#include "llwindow.h"
|
|
|
|
#include "llagent.h"
|
|
#include "llagentpicksinfo.h"
|
|
#include "llfloaterreg.h"
|
|
#include "llfloatersidepanelcontainer.h"
|
|
#include "llfloaterworldmap.h"
|
|
#include "llinventoryobserver.h"
|
|
#include "lllandmarkactions.h"
|
|
#include "lllandmarklist.h"
|
|
#include "llnotificationsutil.h"
|
|
#include "llpanelpick.h"
|
|
#include "llpanelplaceprofile.h"
|
|
#include "llpanellandmarkinfo.h"
|
|
#include "llparcel.h"
|
|
#include "llregionhandle.h" // <FS:Beq/> Var region support
|
|
#include "llteleporthistorystorage.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llviewermessage.h"
|
|
#include "llviewermenu.h"
|
|
#include "llviewerparcelmgr.h"
|
|
#include "llviewerwindow.h"
|
|
#include "llviewerinventory.h"
|
|
#include "rlvactions.h"
|
|
|
|
static const F32 FS_PLACE_INFO_UPDATE_INTERVAL = 3.0f;
|
|
|
|
static bool fs_is_agent_in_selected_parcel(LLParcel* parcel)
|
|
{
|
|
LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
|
|
|
|
LLViewerRegion* region = parcel_mgr->getSelectionRegion();
|
|
if (!region || !parcel)
|
|
return false;
|
|
|
|
return region == gAgent.getRegion() &&
|
|
parcel->getLocalID() == parcel_mgr->getAgentParcel()->getLocalID();
|
|
}
|
|
|
|
|
|
/////////////////////////////////
|
|
// Inventory added observer
|
|
/////////////////////////////////
|
|
|
|
class FSPlaceDetailsInventoryObserver : public LLInventoryAddedObserver
|
|
{
|
|
public:
|
|
FSPlaceDetailsInventoryObserver(FSFloaterPlaceDetails* place_details_floater) :
|
|
mPlaceDetails(place_details_floater)
|
|
{}
|
|
|
|
protected:
|
|
/*virtual*/ void done()
|
|
{
|
|
mPlaceDetails->showAddedLandmarkInfo(gInventory.getAddedIDs());
|
|
}
|
|
|
|
private:
|
|
FSFloaterPlaceDetails* mPlaceDetails;
|
|
};
|
|
|
|
|
|
/////////////////////////////////
|
|
// Remote Parcel info observer
|
|
/////////////////////////////////
|
|
|
|
class FSPlaceDetailsRemoteParcelInfoObserver : public LLRemoteParcelInfoObserver
|
|
{
|
|
public:
|
|
FSPlaceDetailsRemoteParcelInfoObserver(FSFloaterPlaceDetails* place_details_floater) :
|
|
LLRemoteParcelInfoObserver(),
|
|
mPlaceDetails(place_details_floater)
|
|
{}
|
|
|
|
~FSPlaceDetailsRemoteParcelInfoObserver()
|
|
{
|
|
// remove any in-flight observers
|
|
std::set<LLUUID>::iterator it;
|
|
for (it = mParcelIDs.begin(); it != mParcelIDs.end(); ++it)
|
|
{
|
|
const LLUUID &id = *it;
|
|
LLRemoteParcelInfoProcessor::getInstance()->removeObserver(id, this);
|
|
}
|
|
mParcelIDs.clear();
|
|
}
|
|
|
|
/*virtual*/ void processParcelInfo(const LLParcelData& parcel_data)
|
|
{
|
|
if (mPlaceDetails)
|
|
{
|
|
mPlaceDetails->changedGlobalPos(LLVector3d(parcel_data.global_x,
|
|
parcel_data.global_y,
|
|
parcel_data.global_z));
|
|
|
|
mPlaceDetails->processParcelDetails(parcel_data);
|
|
}
|
|
|
|
mParcelIDs.erase(parcel_data.parcel_id);
|
|
LLRemoteParcelInfoProcessor::getInstance()->removeObserver(parcel_data.parcel_id, this);
|
|
}
|
|
/*virtual*/ void setParcelID(const LLUUID& parcel_id)
|
|
{
|
|
if (!parcel_id.isNull())
|
|
{
|
|
mParcelIDs.insert(parcel_id);
|
|
LLRemoteParcelInfoProcessor::getInstance()->addObserver(parcel_id, this);
|
|
LLRemoteParcelInfoProcessor::getInstance()->sendParcelInfoRequest(parcel_id);
|
|
}
|
|
}
|
|
/*virtual*/ void setErrorStatus(S32 status, const std::string& reason)
|
|
{
|
|
LL_WARNS() << "Can't complete remote parcel request. Http Status: "
|
|
<< status << ". Reason : " << reason << LL_ENDL;
|
|
}
|
|
|
|
private:
|
|
std::set<LLUUID> mParcelIDs;
|
|
FSFloaterPlaceDetails* mPlaceDetails;
|
|
};
|
|
|
|
|
|
/////////////////////////////////
|
|
// Parcel info observer
|
|
/////////////////////////////////
|
|
|
|
class FSPlaceDetailsPlacesParcelObserver : public LLParcelObserver
|
|
{
|
|
public:
|
|
FSPlaceDetailsPlacesParcelObserver(FSFloaterPlaceDetails* place_details_floater) :
|
|
LLParcelObserver(),
|
|
mPlaceDetails(place_details_floater)
|
|
{}
|
|
|
|
/*virtual*/ void changed()
|
|
{
|
|
if (mPlaceDetails)
|
|
{
|
|
mPlaceDetails->changedParcelSelection();
|
|
}
|
|
}
|
|
|
|
private:
|
|
FSFloaterPlaceDetails* mPlaceDetails;
|
|
};
|
|
|
|
///////////////////////////////////////
|
|
// FSFloaterPlaceDetails implementation
|
|
///////////////////////////////////////
|
|
|
|
FSFloaterPlaceDetails::FSFloaterPlaceDetails(const LLSD& seed)
|
|
: LLFloater(seed),
|
|
mPanelLandmarkInfo(NULL),
|
|
mPanelPlaceInfo(NULL),
|
|
mIsInEditMode(false),
|
|
mIsInCreateMode(false),
|
|
mGlobalPos(),
|
|
mDisplayInfo(NONE),
|
|
mPickPanel(NULL)
|
|
{
|
|
mParcelObserver = new FSPlaceDetailsPlacesParcelObserver(this);
|
|
mRemoteParcelObserver = new FSPlaceDetailsRemoteParcelInfoObserver(this);
|
|
mInventoryObserver = new FSPlaceDetailsInventoryObserver(this);
|
|
gInventory.addObserver(mInventoryObserver);
|
|
|
|
mAgentParcelChangedConnection = gAgent.addParcelChangedCallback(
|
|
boost::bind(&FSFloaterPlaceDetails::updateVerbs, this));
|
|
}
|
|
|
|
FSFloaterPlaceDetails::~FSFloaterPlaceDetails()
|
|
{
|
|
if (gInventory.containsObserver(mInventoryObserver))
|
|
{
|
|
gInventory.removeObserver(mInventoryObserver);
|
|
}
|
|
LLViewerParcelMgr::getInstance()->removeObserver(mParcelObserver);
|
|
mParcel.clear();
|
|
|
|
delete mInventoryObserver;
|
|
delete mRemoteParcelObserver;
|
|
delete mParcelObserver;
|
|
|
|
if (mAgentParcelChangedConnection.connected())
|
|
{
|
|
mAgentParcelChangedConnection.disconnect();
|
|
}
|
|
}
|
|
|
|
BOOL FSFloaterPlaceDetails::postBuild()
|
|
{
|
|
mPanelLandmarkInfo = findChild<LLPanelLandmarkInfo>("panel_landmark_info");
|
|
mPanelPlaceInfo = findChild<LLPanelPlaceProfile>("panel_place_profile");
|
|
|
|
if (!mPanelLandmarkInfo || !mPanelPlaceInfo)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
getChild<LLButton>("teleport_btn")->setClickedCallback(boost::bind(&FSFloaterPlaceDetails::onTeleportButtonClicked, this));
|
|
getChild<LLButton>("map_btn")->setClickedCallback(boost::bind(&FSFloaterPlaceDetails::onShowOnMapButtonClicked, this));
|
|
getChild<LLButton>("edit_btn")->setClickedCallback(boost::bind(&FSFloaterPlaceDetails::onEditButtonClicked, this));
|
|
getChild<LLButton>("save_btn")->setClickedCallback(boost::bind(&FSFloaterPlaceDetails::onSaveButtonClicked, this));
|
|
getChild<LLButton>("cancel_btn")->setClickedCallback(boost::bind(&FSFloaterPlaceDetails::onCancelButtonClicked, this));
|
|
getChild<LLButton>("close_btn")->setClickedCallback(boost::bind(&FSFloaterPlaceDetails::onCloseButtonClicked, this));
|
|
|
|
LLLineEditor* title_editor = mPanelLandmarkInfo->getChild<LLLineEditor>("title_editor");
|
|
title_editor->setKeystrokeCallback(boost::bind(&FSFloaterPlaceDetails::onEditButtonClicked, this), NULL);
|
|
|
|
LLTextEditor* notes_editor = mPanelLandmarkInfo->getChild<LLTextEditor>("notes_editor");
|
|
notes_editor->setKeystrokeCallback(boost::bind(&FSFloaterPlaceDetails::onEditButtonClicked, this));
|
|
|
|
LLComboBox* folder_combo = mPanelLandmarkInfo->getChild<LLComboBox>("folder_combo");
|
|
folder_combo->setCommitCallback(boost::bind(&FSFloaterPlaceDetails::onEditButtonClicked, this));
|
|
|
|
mOverflowBtn = getChild<LLMenuButton>("overflow_btn");
|
|
mOverflowBtn->setMouseDownCallback(boost::bind(&FSFloaterPlaceDetails::onOverflowButtonClicked, this));
|
|
|
|
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
|
|
registrar.add("Places.OverflowMenu.Action", boost::bind(&FSFloaterPlaceDetails::onOverflowMenuItemClicked, this, _2));
|
|
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
|
|
enable_registrar.add("Places.OverflowMenu.Enable", boost::bind(&FSFloaterPlaceDetails::onOverflowMenuItemEnable, this, _2));
|
|
|
|
mPlaceMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_place.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
|
|
if (!mPlaceMenu)
|
|
{
|
|
LL_WARNS() << "Error loading Place menu" << LL_ENDL;
|
|
}
|
|
|
|
mLandmarkMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_landmark.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
|
|
if (!mLandmarkMenu)
|
|
{
|
|
LL_WARNS() << "Error loading Landmark menu" << LL_ENDL;
|
|
}
|
|
|
|
updateVerbs();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onOpen(const LLSD& key)
|
|
{
|
|
mIsInCreateMode = false;
|
|
mIsInEditMode = false;
|
|
|
|
if (key.size() != 0)
|
|
{
|
|
std::string key_type = key["type"].asString();
|
|
|
|
if (key_type == "landmark")
|
|
{
|
|
mDisplayInfo = LANDMARK;
|
|
setTitle(getString("title_landmark"));
|
|
|
|
LLInventoryItem* item = gInventory.getItem(key["id"].asUUID());
|
|
if (!item)
|
|
{
|
|
return;
|
|
}
|
|
|
|
mPanelLandmarkInfo->resetLocation();
|
|
mPanelLandmarkInfo->setInfoType(LLPanelPlaceInfo::LANDMARK);
|
|
mPanelLandmarkInfo->setHeaderVisible(FALSE);
|
|
|
|
mPanelPlaceInfo->setVisible(FALSE);
|
|
mPanelLandmarkInfo->setVisible(TRUE);
|
|
|
|
setItem(item);
|
|
}
|
|
else if (key_type == "create_landmark")
|
|
{
|
|
mDisplayInfo = CREATE_LANDMARK;
|
|
setTitle(getString("title_create_landmark"));
|
|
|
|
if (key.has("x") && key.has("y") && key.has("z"))
|
|
{
|
|
mGlobalPos = LLVector3d(key["x"].asReal(),
|
|
key["y"].asReal(),
|
|
key["z"].asReal());
|
|
}
|
|
else
|
|
{
|
|
mGlobalPos = gAgent.getPositionGlobal();
|
|
}
|
|
|
|
mPanelLandmarkInfo->resetLocation();
|
|
mPanelLandmarkInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK);
|
|
mPanelLandmarkInfo->setHeaderVisible(FALSE);
|
|
mPanelLandmarkInfo->displayParcelInfo(LLUUID(), mGlobalPos);
|
|
|
|
mPanelPlaceInfo->setVisible(FALSE);
|
|
mPanelLandmarkInfo->setVisible(TRUE);
|
|
|
|
mIsInCreateMode = true;
|
|
updateVerbs();
|
|
}
|
|
else if (key_type == "remote_place")
|
|
{
|
|
mDisplayInfo = REMOTE_PLACE;
|
|
setTitle(getString("title_remote_place"));
|
|
|
|
mPanelPlaceInfo->resetLocation();
|
|
mPanelPlaceInfo->setInfoType(LLPanelPlaceInfo::PLACE);
|
|
mPanelPlaceInfo->setHeaderVisible(FALSE);
|
|
mPanelPlaceInfo->setVisible(TRUE);
|
|
mPanelLandmarkInfo->setVisible(FALSE);
|
|
|
|
if (key.has("id"))
|
|
{
|
|
LLUUID parcel_id = key["id"].asUUID();
|
|
mPanelPlaceInfo->setParcelID(parcel_id);
|
|
|
|
// query the server to get the global 3D position of this
|
|
// parcel - we need this for teleport/mapping functions.
|
|
mRemoteParcelObserver->setParcelID(parcel_id);
|
|
}
|
|
else
|
|
{
|
|
mGlobalPos = LLVector3d(key["x"].asReal(),
|
|
key["y"].asReal(),
|
|
key["z"].asReal());
|
|
|
|
mPanelPlaceInfo->setParcelDetailLoadedCallback(boost::bind(&FSFloaterPlaceDetails::processParcelDetails, this, _1));
|
|
if(key.has("ox"))
|
|
{
|
|
auto region_handle = to_region_handle(key["ox"].asInteger(), key["oy"].asInteger());
|
|
mPanelPlaceInfo->displayParcelInfo(LLUUID(), region_handle, mGlobalPos);
|
|
}
|
|
else
|
|
{
|
|
mPanelPlaceInfo->displayParcelInfo(LLUUID(), mGlobalPos);
|
|
}
|
|
}
|
|
|
|
updateVerbs();
|
|
}
|
|
else if (key_type == "teleport_history")
|
|
{
|
|
mDisplayInfo = TELEPORT_HISTORY_ITEM;
|
|
|
|
S32 index = key["id"].asInteger();
|
|
|
|
const LLTeleportHistoryStorage::slurl_list_t& hist_items =
|
|
LLTeleportHistoryStorage::getInstance()->getItems();
|
|
|
|
mGlobalPos = hist_items[index].mGlobalPos;
|
|
|
|
LLStringUtil::format_map_t args;
|
|
args["[NAME]"] = hist_items[index].mTitle.c_str();
|
|
setTitle(getString("title_teleport_history_item", args));
|
|
|
|
mPanelPlaceInfo->resetLocation();
|
|
mPanelPlaceInfo->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY);
|
|
mPanelPlaceInfo->displayParcelInfo(LLUUID(), mGlobalPos);
|
|
|
|
mPanelPlaceInfo->setHeaderVisible(FALSE);
|
|
mPanelPlaceInfo->setVisible(TRUE);
|
|
mPanelLandmarkInfo->setVisible(FALSE);
|
|
|
|
updateVerbs();
|
|
}
|
|
else if (key_type == "agent")
|
|
{
|
|
mDisplayInfo = AGENT;
|
|
|
|
setTitle(getString("title_place"));
|
|
|
|
mPanelPlaceInfo->resetLocation();
|
|
mPanelPlaceInfo->setInfoType(LLPanelPlaceInfo::AGENT);
|
|
mPanelPlaceInfo->setHeaderVisible(FALSE);
|
|
mPanelPlaceInfo->setVisible(TRUE);
|
|
mPanelLandmarkInfo->setVisible(FALSE);
|
|
|
|
LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
|
|
if (!parcel_mgr)
|
|
{
|
|
return;
|
|
}
|
|
// We don't know if we are already added to LLViewerParcelMgr observers list
|
|
// so try to remove observer not to add an extra one.
|
|
parcel_mgr->removeObserver(mParcelObserver);
|
|
parcel_mgr->addObserver(mParcelObserver);
|
|
parcel_mgr->selectParcelAt(gAgent.getPositionGlobal());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FSFloaterPlaceDetails::updateVerbs()
|
|
{
|
|
if (mDisplayInfo == NONE)
|
|
{
|
|
getChildView("teleport_btn")->setVisible(!(mIsInEditMode || mIsInCreateMode));
|
|
getChildView("map_btn")->setVisible(!(mIsInEditMode || mIsInCreateMode));
|
|
getChildView("edit_btn")->setVisible(!(mIsInEditMode || mIsInCreateMode));
|
|
getChildView("save_btn")->setVisible(mIsInEditMode);
|
|
getChildView("cancel_btn")->setVisible(mIsInEditMode);
|
|
getChildView("close_btn")->setVisible(mIsInCreateMode);
|
|
|
|
return;
|
|
}
|
|
|
|
bool have_position = !mGlobalPos.isExactlyZero();
|
|
getChildView("teleport_btn")->setEnabled(have_position);
|
|
getChildView("map_btn")->setEnabled(have_position);
|
|
|
|
if (mDisplayInfo == CREATE_LANDMARK || mDisplayInfo == LANDMARK)
|
|
{
|
|
getChildView("teleport_btn")->setVisible(!(mIsInEditMode || mIsInCreateMode));
|
|
getChildView("map_btn")->setVisible(!(mIsInEditMode || mIsInCreateMode));
|
|
getChildView("edit_btn")->setVisible(!(mIsInEditMode || mIsInCreateMode));
|
|
getChildView("save_btn")->setVisible(mIsInEditMode);
|
|
getChildView("cancel_btn")->setVisible(mIsInEditMode);
|
|
getChildView("close_btn")->setVisible(mIsInCreateMode);
|
|
mOverflowBtn->setVisible(!(mIsInEditMode || mIsInCreateMode));
|
|
}
|
|
else if (mDisplayInfo == REMOTE_PLACE || mDisplayInfo == TELEPORT_HISTORY_ITEM)
|
|
{
|
|
getChildView("teleport_btn")->setVisible(TRUE);
|
|
getChildView("teleport_btn")->setEnabled(RlvActions::canTeleportToLocation());
|
|
getChildView("map_btn")->setVisible(TRUE);
|
|
getChildView("edit_btn")->setVisible(FALSE);
|
|
getChildView("save_btn")->setVisible(FALSE);
|
|
getChildView("cancel_btn")->setVisible(FALSE);
|
|
getChildView("close_btn")->setVisible(FALSE);
|
|
}
|
|
else if (mDisplayInfo == AGENT)
|
|
{
|
|
getChildView("teleport_btn")->setVisible(TRUE);
|
|
getChildView("teleport_btn")->setEnabled(have_position && !LLViewerParcelMgr::getInstance()->inAgentParcel(mGlobalPos));
|
|
getChildView("map_btn")->setVisible(TRUE);
|
|
getChildView("edit_btn")->setVisible(FALSE);
|
|
getChildView("save_btn")->setVisible(FALSE);
|
|
getChildView("cancel_btn")->setVisible(FALSE);
|
|
getChildView("close_btn")->setVisible(FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void FSFloaterPlaceDetails::showAddedLandmarkInfo(const uuid_set_t& items)
|
|
{
|
|
for (uuid_set_t::const_iterator item_iter = items.begin();
|
|
item_iter != items.end();
|
|
++item_iter)
|
|
{
|
|
const LLUUID& item_id = (*item_iter);
|
|
if(!highlight_offered_object(item_id))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
LLInventoryItem* item = gInventory.getItem(item_id);
|
|
|
|
llassert(item);
|
|
if (item && (LLAssetType::AT_LANDMARK == item->getType()) )
|
|
{
|
|
// Created landmark is passed to Places panel to allow its editing.
|
|
// If the panel is closed we don't reopen it until created landmark is loaded.
|
|
//if("create_landmark" == getPlaceInfoType() && !getItem())
|
|
//{
|
|
setItem(item);
|
|
//}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::setItem(LLInventoryItem* item)
|
|
{
|
|
if (!item)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (mDisplayInfo == LANDMARK)
|
|
{
|
|
LLStringUtil::format_map_t args;
|
|
args["[NAME]"] = item->getName().c_str();
|
|
setTitle(getString("title_landmark_detail", args));
|
|
}
|
|
|
|
mItem = item;
|
|
|
|
LLAssetType::EType item_type = mItem->getActualType();
|
|
if (item_type == LLAssetType::AT_LANDMARK || item_type == LLAssetType::AT_LINK)
|
|
{
|
|
// If the item is a link get a linked item
|
|
if (item_type == LLAssetType::AT_LINK)
|
|
{
|
|
mItem = gInventory.getItem(mItem->getLinkedUUID());
|
|
if (mItem.isNull())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Check if item is in agent's inventory and he has the permission to modify it.
|
|
BOOL is_landmark_editable = gInventory.isObjectDescendentOf(mItem->getUUID(), gInventory.getRootFolderID()) &&
|
|
mItem->getPermissions().allowModifyBy(gAgent.getID());
|
|
|
|
getChildView("edit_btn")->setEnabled(is_landmark_editable);
|
|
getChildView("save_btn")->setEnabled(is_landmark_editable);
|
|
|
|
if (is_landmark_editable)
|
|
{
|
|
if(!mPanelLandmarkInfo->setLandmarkFolder(mItem->getParentUUID()) && !mItem->getParentUUID().isNull())
|
|
{
|
|
const LLViewerInventoryCategory* cat = gInventory.getCategory(mItem->getParentUUID());
|
|
if (cat)
|
|
{
|
|
std::string cat_fullname = LLPanelLandmarkInfo::getFullFolderName(cat);
|
|
LLComboBox* folderList = mPanelLandmarkInfo->getChild<LLComboBox>("folder_combo");
|
|
folderList->add(cat_fullname, cat->getUUID(), ADD_TOP);
|
|
}
|
|
}
|
|
}
|
|
|
|
mPanelLandmarkInfo->displayItemInfo(mItem);
|
|
|
|
LLLandmark* lm = gLandmarkList.getAsset(mItem->getAssetUUID(),
|
|
boost::bind(&FSFloaterPlaceDetails::onLandmarkLoaded, this, _1));
|
|
if (lm)
|
|
{
|
|
onLandmarkLoaded(lm);
|
|
}
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::togglePickPanel(BOOL visible)
|
|
{
|
|
if (mPickPanel)
|
|
{
|
|
mPickPanel->setVisible(visible);
|
|
}
|
|
}
|
|
|
|
// static
|
|
void FSFloaterPlaceDetails::showPlaceDetails(const LLSD& key)
|
|
{
|
|
if (gSavedSettings.getBOOL("FSUseStandalonePlaceDetailsFloater"))
|
|
{
|
|
LLFloaterReg::showInstance("fs_placedetails", key);
|
|
}
|
|
else
|
|
{
|
|
LLFloaterSidePanelContainer::showPanel("places", key);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// Button event handlers
|
|
/////////////////////////////////
|
|
|
|
void FSFloaterPlaceDetails::onTeleportButtonClicked()
|
|
{
|
|
if (mDisplayInfo == LANDMARK || mDisplayInfo == CREATE_LANDMARK)
|
|
{
|
|
if (mItem.isNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLSD payload;
|
|
payload["asset_id"] = mItem->getAssetUUID();
|
|
LLSD args;
|
|
args["LOCATION"] = mItem->getName();
|
|
LLNotificationsUtil::add("TeleportFromLandmark", args, payload);
|
|
}
|
|
else if (mDisplayInfo == REMOTE_PLACE || mDisplayInfo == TELEPORT_HISTORY_ITEM || mDisplayInfo == AGENT)
|
|
{
|
|
LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
|
|
if (!mGlobalPos.isExactlyZero() && worldmap_instance)
|
|
{
|
|
gAgent.teleportViaLocation(mGlobalPos);
|
|
worldmap_instance->trackLocation(mGlobalPos);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onShowOnMapButtonClicked()
|
|
{
|
|
LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
|
|
if(!worldmap_instance)
|
|
return;
|
|
|
|
if (mDisplayInfo == LANDMARK || mDisplayInfo == CREATE_LANDMARK)
|
|
{
|
|
LLLandmark* landmark = gLandmarkList.getAsset(mItem->getAssetUUID());
|
|
if (!landmark)
|
|
return;
|
|
|
|
LLVector3d landmark_global_pos;
|
|
if (!landmark->getGlobalPos(landmark_global_pos))
|
|
return;
|
|
|
|
if (!landmark_global_pos.isExactlyZero())
|
|
{
|
|
worldmap_instance->trackLocation(landmark_global_pos);
|
|
LLFloaterReg::showInstance("world_map", "center");
|
|
}
|
|
}
|
|
else if (mDisplayInfo == REMOTE_PLACE || mDisplayInfo == TELEPORT_HISTORY_ITEM || mDisplayInfo == AGENT)
|
|
{
|
|
if (!mGlobalPos.isExactlyZero())
|
|
{
|
|
worldmap_instance->trackLocation(mGlobalPos);
|
|
LLFloaterReg::showInstance("world_map", "center");
|
|
}
|
|
}
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onEditButtonClicked()
|
|
{
|
|
mPanelLandmarkInfo->toggleLandmarkEditMode(TRUE);
|
|
mIsInEditMode = true;
|
|
mIsInCreateMode = false;
|
|
updateVerbs();
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onCancelButtonClicked()
|
|
{
|
|
mPanelLandmarkInfo->toggleLandmarkEditMode(FALSE);
|
|
mIsInEditMode = false;
|
|
|
|
updateVerbs();
|
|
|
|
// Reload the landmark properties.
|
|
mPanelLandmarkInfo->displayItemInfo(mItem);
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onSaveButtonClicked()
|
|
{
|
|
if (mItem.isNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::string current_title_value = mPanelLandmarkInfo->getLandmarkTitle();
|
|
std::string item_title_value = mItem->getName();
|
|
std::string current_notes_value = mPanelLandmarkInfo->getLandmarkNotes();
|
|
std::string item_notes_value = mItem->getDescription();
|
|
|
|
LLStringUtil::trim(current_title_value);
|
|
LLStringUtil::trim(current_notes_value);
|
|
|
|
LLUUID item_id = mItem->getUUID();
|
|
LLUUID folder_id = mPanelLandmarkInfo->getLandmarkFolder();
|
|
|
|
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(mItem);
|
|
|
|
if (!current_title_value.empty() &&
|
|
(item_title_value != current_title_value || item_notes_value != current_notes_value))
|
|
{
|
|
new_item->rename(current_title_value);
|
|
new_item->setDescription(current_notes_value);
|
|
new_item->updateServer(FALSE);
|
|
}
|
|
|
|
if(folder_id != mItem->getParentUUID())
|
|
{
|
|
LLInventoryModel::update_list_t update;
|
|
LLInventoryModel::LLCategoryUpdate old_folder(mItem->getParentUUID(),-1);
|
|
update.push_back(old_folder);
|
|
LLInventoryModel::LLCategoryUpdate new_folder(folder_id, 1);
|
|
update.push_back(new_folder);
|
|
gInventory.accountForUpdate(update);
|
|
|
|
new_item->setParent(folder_id);
|
|
new_item->updateParentOnServer(FALSE);
|
|
}
|
|
|
|
gInventory.updateItem(new_item);
|
|
gInventory.notifyObservers();
|
|
|
|
onCancelButtonClicked();
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onCloseButtonClicked()
|
|
{
|
|
onSaveButtonClicked();
|
|
closeFloater();
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onOverflowButtonClicked()
|
|
{
|
|
LLToggleableMenu* menu;
|
|
|
|
if ((mDisplayInfo == TELEPORT_HISTORY_ITEM || mDisplayInfo == REMOTE_PLACE || mDisplayInfo == AGENT) && mPlaceMenu)
|
|
{
|
|
menu = mPlaceMenu;
|
|
|
|
// STORM-411
|
|
// Creating landmarks for remote locations is impossible.
|
|
// So hide menu item "Make a Landmark" in "Teleport History Profile" panel.
|
|
menu->setItemVisible("landmark", mDisplayInfo == AGENT);
|
|
menu->arrangeAndClear();
|
|
}
|
|
else if ((mDisplayInfo == LANDMARK || mDisplayInfo == CREATE_LANDMARK) && mLandmarkMenu)
|
|
{
|
|
menu = mLandmarkMenu;
|
|
|
|
BOOL is_landmark_removable = FALSE;
|
|
if (mItem.notNull())
|
|
{
|
|
const LLUUID& item_id = mItem->getUUID();
|
|
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
|
|
is_landmark_removable = gInventory.isObjectDescendentOf(item_id, gInventory.getRootFolderID()) &&
|
|
!gInventory.isObjectDescendentOf(item_id, trash_id);
|
|
}
|
|
|
|
menu->getChild<LLMenuItemCallGL>("delete")->setEnabled(is_landmark_removable);
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
// TODO: What to do with the create pick stuff? Disabled for now...
|
|
menu->getChild<LLMenuItemCallGL>("pick")->setVisible(FALSE);
|
|
|
|
mOverflowBtn->setMenu(menu, LLMenuButton::MP_TOP_RIGHT);
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onOverflowMenuItemClicked(const LLSD& param)
|
|
{
|
|
std::string item = param.asString();
|
|
if (item == "landmark")
|
|
{
|
|
LLSD key;
|
|
key["type"] = "create_landmark";
|
|
key["x"] = mGlobalPos.mdV[VX];
|
|
key["y"] = mGlobalPos.mdV[VY];
|
|
key["z"] = mGlobalPos.mdV[VZ];
|
|
|
|
LLFloaterReg::showInstance("fs_placedetails", key);
|
|
}
|
|
else if (item == "copy")
|
|
{
|
|
LLLandmarkActions::getSLURLfromPosGlobal(mGlobalPos, boost::bind(&FSFloaterPlaceDetails::onSLURLBuilt, this, _1));
|
|
}
|
|
else if (item == "delete")
|
|
{
|
|
gInventory.removeItem(mItem->getUUID());
|
|
closeFloater();
|
|
}
|
|
else if (item == "pick")
|
|
{
|
|
if (mPickPanel == NULL)
|
|
{
|
|
mPickPanel = LLPanelPickEdit::create();
|
|
addChild(mPickPanel);
|
|
|
|
mPickPanel->setExitCallback(boost::bind(&FSFloaterPlaceDetails::togglePickPanel, this, FALSE));
|
|
mPickPanel->setCancelCallback(boost::bind(&FSFloaterPlaceDetails::togglePickPanel, this, FALSE));
|
|
mPickPanel->setSaveCallback(boost::bind(&FSFloaterPlaceDetails::togglePickPanel, this, FALSE));
|
|
}
|
|
|
|
togglePickPanel(TRUE);
|
|
mPickPanel->onOpen(LLSD());
|
|
|
|
LLPanelPlaceInfo* panel = mPanelPlaceInfo;
|
|
if (mDisplayInfo == LANDMARK)
|
|
{
|
|
panel = mPanelLandmarkInfo;
|
|
}
|
|
|
|
if (panel)
|
|
{
|
|
panel->createPick(mGlobalPos, mPickPanel);
|
|
|
|
LLRect rect = panel->getRect();
|
|
mPickPanel->reshape(rect.getWidth(), rect.getHeight());
|
|
mPickPanel->setRect(rect);
|
|
}
|
|
}
|
|
else if (item == "add_to_favbar")
|
|
{
|
|
if ( mItem.notNull() )
|
|
{
|
|
const LLUUID& favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
|
|
if ( favorites_id.notNull() )
|
|
{
|
|
copy_inventory_item(gAgent.getID(),
|
|
mItem->getPermissions().getOwner(),
|
|
mItem->getUUID(),
|
|
favorites_id,
|
|
std::string(),
|
|
LLPointer<LLInventoryCallback>(NULL));
|
|
LL_INFOS() << "Copied inventory item #" << mItem->getUUID() << " to favorites." << LL_ENDL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FSFloaterPlaceDetails::onOverflowMenuItemEnable(const LLSD& param)
|
|
{
|
|
std::string value = param.asString();
|
|
if("can_create_pick" == value)
|
|
{
|
|
return !LLAgentPicksInfo::getInstance()->isPickLimitReached();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::onSLURLBuilt(std::string& slurl)
|
|
{
|
|
getWindow()->copyTextToClipboard(utf8str_to_wstring(slurl));
|
|
|
|
LLSD args;
|
|
args["SLURL"] = slurl;
|
|
|
|
LLNotificationsUtil::add("CopySLURL", args);
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// Callbacks
|
|
/////////////////////////////////
|
|
|
|
void FSFloaterPlaceDetails::onLandmarkLoaded(LLLandmark* landmark)
|
|
{
|
|
if (!mPanelLandmarkInfo)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLUUID region_id;
|
|
landmark->getRegionID(region_id);
|
|
landmark->getGlobalPos(mGlobalPos);
|
|
mPanelLandmarkInfo->displayParcelInfo(region_id, mGlobalPos);
|
|
updateVerbs();
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::changedGlobalPos(const LLVector3d& global_pos)
|
|
{
|
|
mGlobalPos = global_pos;
|
|
updateVerbs();
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::processParcelDetails(const LLParcelData& parcel_details)
|
|
{
|
|
LLStringUtil::format_map_t args;
|
|
args["[NAME]"] = parcel_details.name.c_str();
|
|
setTitle(getString("title_remote_place_detail", args));
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::changedParcelSelection()
|
|
{
|
|
if (!mPanelPlaceInfo)
|
|
return;
|
|
|
|
LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
|
|
mParcel = parcel_mgr->getFloatingParcelSelection();
|
|
LLParcel* parcel = mParcel->getParcel();
|
|
LLViewerRegion* region = parcel_mgr->getSelectionRegion();
|
|
if (!region || !parcel)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLVector3d prev_pos_global = mGlobalPos;
|
|
|
|
// If agent is inside the selected parcel show agent's region<X, Y, Z>,
|
|
// otherwise show region<X, Y, Z> of agent's selection point.
|
|
bool is_current_parcel = fs_is_agent_in_selected_parcel(parcel);
|
|
if (is_current_parcel)
|
|
{
|
|
mGlobalPos = gAgent.getPositionGlobal();
|
|
}
|
|
else
|
|
{
|
|
LLVector3d pos_global = gViewerWindow->getLastPick().mPosGlobal;
|
|
if (!pos_global.isExactlyZero())
|
|
{
|
|
mGlobalPos = pos_global;
|
|
}
|
|
}
|
|
|
|
// Reset location info only if global position has changed
|
|
// and update timer has expired to reduce unnecessary text and icons updates.
|
|
if (prev_pos_global != mGlobalPos && mResetInfoTimer.hasExpired())
|
|
{
|
|
mPanelPlaceInfo->resetLocation();
|
|
mResetInfoTimer.setTimerExpirySec(FS_PLACE_INFO_UPDATE_INTERVAL);
|
|
}
|
|
|
|
mPanelPlaceInfo->displaySelectedParcelInfo(parcel, region, mGlobalPos, is_current_parcel);
|
|
|
|
updateVerbs();
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::updateEstateName(const std::string& name)
|
|
{
|
|
if (mPanelPlaceInfo)
|
|
{
|
|
mPanelPlaceInfo->updateEstateName(name);
|
|
}
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::updateEstateOwnerName(const std::string& name)
|
|
{
|
|
if (mPanelPlaceInfo)
|
|
{
|
|
mPanelPlaceInfo->updateEstateOwnerName(name);
|
|
}
|
|
}
|
|
|
|
void FSFloaterPlaceDetails::updateCovenantText(const std::string &text)
|
|
{
|
|
if (mPanelPlaceInfo)
|
|
{
|
|
mPanelPlaceInfo->updateCovenantText(text);
|
|
}
|
|
}
|