510 lines
15 KiB
C++
Executable File
510 lines
15 KiB
C++
Executable File
/**
|
|
* @file llfloatermap.cpp
|
|
* @brief The "mini-map" or radar in the upper right part of the screen.
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
// self include
|
|
#include "llfloatermap.h"
|
|
|
|
// Library includes
|
|
#include "llfloaterreg.h"
|
|
#include "llfontgl.h"
|
|
#include "llglheaders.h"
|
|
|
|
// Viewer includes
|
|
#include "llagentcamera.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llnetmap.h"
|
|
#include "lltracker.h"
|
|
#include "llviewercamera.h"
|
|
#include "lldraghandle.h"
|
|
#include "lltextbox.h"
|
|
#include "llfloaterworldmap.h"
|
|
#include "llagent.h"
|
|
|
|
// Firestorm includes
|
|
#include "rlvhandler.h"
|
|
#include "llavataractions.h"
|
|
#include "llavatarnamecache.h"
|
|
#include "llfloatersidepanelcontainer.h"
|
|
#include "lltrans.h"
|
|
#include "llviewerobject.h"
|
|
#include "llviewerparceloverlay.h"
|
|
#include "llviewerparcelmgr.h"
|
|
#include "llviewermenu.h"
|
|
#include "llworld.h" // <FS:CR> Aurora Sim
|
|
|
|
//
|
|
// Constants
|
|
//
|
|
|
|
// The minor cardinal direction labels are hidden if their height is more
|
|
// than this proportion of the map.
|
|
const F32 MAP_MINOR_DIR_THRESHOLD = 0.07f;
|
|
const S32 MAP_PADDING_LEFT = 0;
|
|
const S32 MAP_PADDING_TOP = 2;
|
|
const S32 MAP_PADDING_RIGHT = 2;
|
|
const S32 MAP_PADDING_BOTTOM = 0;
|
|
//
|
|
// Member functions
|
|
//
|
|
|
|
LLFloaterMap::LLFloaterMap(const LLSD& key)
|
|
: LLFloater(key),
|
|
mTextBoxEast(NULL),
|
|
mTextBoxNorth(NULL),
|
|
mTextBoxWest(NULL),
|
|
mTextBoxSouth(NULL),
|
|
mTextBoxSouthEast(NULL),
|
|
mTextBoxNorthEast(NULL),
|
|
mTextBoxNorthWest(NULL),
|
|
mTextBoxSouthWest(NULL),
|
|
mPopupMenu(NULL), // <FS:CR>
|
|
mMap(NULL)
|
|
{
|
|
}
|
|
|
|
LLFloaterMap::~LLFloaterMap()
|
|
{
|
|
}
|
|
|
|
BOOL LLFloaterMap::postBuild()
|
|
{
|
|
mMap = getChild<LLNetMap>("Net Map");
|
|
// <FS:Ansariel> Synchronize tooltips throughout instances
|
|
//if (gSavedSettings.getBOOL("DoubleClickTeleport"))
|
|
//{
|
|
// mMap->setToolTipMsg(getString("AltToolTipMsg"));
|
|
//}
|
|
//else if (gSavedSettings.getBOOL("DoubleClickShowWorldMap"))
|
|
//{
|
|
// mMap->setToolTipMsg(getString("ToolTipMsg"));
|
|
//}
|
|
// </FS:Ansariel> Synchronize tooltips throughout instances
|
|
sendChildToBack(mMap);
|
|
|
|
mTextBoxNorth = getChild<LLTextBox> ("floater_map_north");
|
|
mTextBoxEast = getChild<LLTextBox> ("floater_map_east");
|
|
mTextBoxWest = getChild<LLTextBox> ("floater_map_west");
|
|
mTextBoxSouth = getChild<LLTextBox> ("floater_map_south");
|
|
mTextBoxSouthEast = getChild<LLTextBox> ("floater_map_southeast");
|
|
mTextBoxNorthEast = getChild<LLTextBox> ("floater_map_northeast");
|
|
mTextBoxSouthWest = getChild<LLTextBox> ("floater_map_southwest");
|
|
mTextBoxNorthWest = getChild<LLTextBox> ("floater_map_northwest");
|
|
|
|
// <Firestorm Minimap changes>
|
|
LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
|
|
|
|
registrar.add("Minimap.Zoom", boost::bind(&LLFloaterMap::handleZoom, this, _2));
|
|
registrar.add("Minimap.Tracker", boost::bind(&LLFloaterMap::handleStopTracking, this, _2));
|
|
|
|
registrar.add("Minimap.Mark", boost::bind(&LLFloaterMap::handleMark, this, _2));
|
|
registrar.add("Minimap.ClearMarks", boost::bind(&LLFloaterMap::handleClearMarks, this));
|
|
|
|
registrar.add("Minimap.Cam", boost::bind(&LLFloaterMap::handleCam, this));
|
|
registrar.add("Minimap.StartTracking", boost::bind(&LLFloaterMap::handleStartTracking, this));
|
|
|
|
// [SL:KB] - Patch: World-MiniMap | Checked: 2012-07-08 (Catznip-3.3.0)
|
|
registrar.add("Minimap.ShowProfile", boost::bind(&LLFloaterMap::handleShowProfile, this, _2));
|
|
registrar.add("Minimap.TextureType", boost::bind(&LLFloaterMap::handleTextureType, this, _2));
|
|
registrar.add("Minimap.ToggleOverlay", boost::bind(&LLFloaterMap::handleOverlayToggle, this, _2));
|
|
|
|
LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
|
|
enable_registrar.add("Minimap.CheckTextureType", boost::bind(&LLFloaterMap::checkTextureType, this, _2));
|
|
// [/SL:KB]
|
|
|
|
// [SL:KB] - Patch: World-MinimapOverlay | Checked: 2012-06-20 (Catznip-3.3.0)
|
|
LLViewerParcelMgr::instance().setCollisionUpdateCallback(boost::bind(&LLFloaterMap::refreshParcelOverlay, this));
|
|
LLViewerParcelOverlay::setUpdateCallback(boost::bind(&LLFloaterMap::refreshParcelOverlay, this));
|
|
// [/SL:KB]
|
|
|
|
mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_mini_map.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
|
|
if (mPopupMenu && !LLTracker::isTracking(0))
|
|
{
|
|
mPopupMenu->setItemEnabled ("Stop Tracking", false);
|
|
}
|
|
// </Firestorm minimap changes>
|
|
|
|
stretchMiniMap(getRect().getWidth() - MAP_PADDING_LEFT - MAP_PADDING_RIGHT,
|
|
getRect().getHeight() - MAP_PADDING_TOP - MAP_PADDING_BOTTOM);
|
|
|
|
updateMinorDirections();
|
|
|
|
// Get the drag handle all the way in back
|
|
sendChildToBack(getDragHandle());
|
|
|
|
setIsChrome(TRUE);
|
|
getDragHandle()->setTitleVisible(TRUE);
|
|
|
|
// keep onscreen
|
|
gFloaterView->adjustToFitScreen(this, FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL LLFloaterMap::handleDoubleClick(S32 x, S32 y, MASK mask)
|
|
{
|
|
// If floater is minimized, minimap should be shown on doubleclick (STORM-299)
|
|
if (isMinimized())
|
|
{
|
|
setMinimized(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
LLVector3d pos_global = mMap->viewPosToGlobal(x, y);
|
|
|
|
// <FS:Ansariel> Synchronize double click handling throughout instances
|
|
//LLTracker::stopTracking(NULL);
|
|
//LLFloaterWorldMap* world_map = LLFloaterWorldMap::getInstance();
|
|
//if (world_map)
|
|
//{
|
|
// world_map->trackLocation(pos_global);
|
|
//}
|
|
//
|
|
//if (gSavedSettings.getBOOL("DoubleClickTeleport"))
|
|
//{
|
|
// // If DoubleClickTeleport is on, double clicking the minimap will teleport there
|
|
// gAgent.teleportViaLocationLookAt(pos_global);
|
|
//}
|
|
//else if (gSavedSettings.getBOOL("DoubleClickShowWorldMap"))
|
|
//{
|
|
// LLFloaterReg::showInstance("world_map");
|
|
//}
|
|
mMap->performDoubleClickAction(pos_global);
|
|
// </FS:Ansariel> Synchronize double click handling throughout instances
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL LLFloaterMap::handleRightMouseDown(S32 x, S32 y, MASK mask)
|
|
{
|
|
if (mPopupMenu)
|
|
{
|
|
// [SL:KB] - Patch: World-MiniMap | Checked: 2012-07-08 (Catznip-3.3.0)
|
|
mMap->mClosestAgentRightClick = mMap->getClosestAgentToCursor();
|
|
mMap->mPosGlobalRightClick = mMap->viewPosToGlobal(x, y);
|
|
|
|
mPopupMenu->setItemVisible("View Profile", mMap->mClosestAgentsToCursor.size() == 1);
|
|
|
|
LLMenuItemBranchGL* pProfilesMenu = mPopupMenu->getChild<LLMenuItemBranchGL>("View Profiles");
|
|
if (pProfilesMenu)
|
|
{
|
|
pProfilesMenu->setVisible(mMap->mClosestAgentsToCursor.size() > 1);
|
|
|
|
pProfilesMenu->getBranch()->empty();
|
|
for (uuid_vec_t::const_iterator itAgent = mMap->mClosestAgentsToCursor.begin(); itAgent != mMap->mClosestAgentsToCursor.end(); ++itAgent)
|
|
{
|
|
LLMenuItemCallGL::Params p;
|
|
p.name = llformat("Profile Item %d", itAgent - mMap->mClosestAgentsToCursor.begin());
|
|
|
|
LLAvatarName avName; const LLUUID& idAgent = *itAgent;
|
|
if (LLAvatarNameCache::get(idAgent, &avName))
|
|
{
|
|
p.label = avName.getCompleteName();
|
|
}
|
|
else
|
|
{
|
|
p.label = LLTrans::getString("LoadingData");
|
|
LLAvatarNameCache::get(idAgent, boost::bind(&LLFloaterMap::setAvatarProfileLabel, this, _2, p.name.getValue()));
|
|
}
|
|
p.on_click.function = boost::bind(&LLAvatarActions::showProfile, _2);
|
|
p.on_click.parameter = idAgent;
|
|
|
|
LLMenuItemCallGL* pMenuItem = LLUICtrlFactory::create<LLMenuItemCallGL>(p);
|
|
if (pMenuItem)
|
|
pProfilesMenu->getBranch()->addChild(pMenuItem);
|
|
}
|
|
}
|
|
mPopupMenu->setItemVisible("Cam", mMap->isZoomable());
|
|
mPopupMenu->setItemVisible("MarkAvatar", mMap->getClosestAgentToCursor().notNull());
|
|
mPopupMenu->setItemVisible("Start Tracking", mMap->getClosestAgentToCursor().notNull());
|
|
mPopupMenu->setItemVisible("Profile Separator", (mMap->mClosestAgentsToCursor.size() >= 1
|
|
|| mMap->getClosestAgentToCursor().notNull()));
|
|
// [/SL:KB]
|
|
mPopupMenu->buildDrawLabels();
|
|
mPopupMenu->updateParent(LLMenuGL::sMenuContainer);
|
|
// [SL:KB] - Patch: World-MiniMap | Checked: 2012-07-08 (Catznip-3.3.0)
|
|
mPopupMenu->setItemVisible("Stop Tracking", LLTracker::isTracking(0));
|
|
mPopupMenu->setItemVisible("Stop Tracking Separator", LLTracker::isTracking(0));
|
|
// [/SL:KB]
|
|
// mPopupMenu->setItemEnabled("Stop Tracking", LLTracker::isTracking(0));
|
|
LLMenuGL::showPopup(this, mPopupMenu, x, y);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void LLFloaterMap::setDirectionPos( LLTextBox* text_box, F32 rotation )
|
|
{
|
|
// Rotation is in radians.
|
|
// Rotation of 0 means x = 1, y = 0 on the unit circle.
|
|
|
|
F32 map_half_height = (F32)(getRect().getHeight() / 2) - getHeaderHeight()/2;
|
|
F32 map_half_width = (F32)(getRect().getWidth() / 2) ;
|
|
F32 text_half_height = (F32)(text_box->getRect().getHeight() / 2);
|
|
F32 text_half_width = (F32)(text_box->getRect().getWidth() / 2);
|
|
F32 radius = llmin( map_half_height - text_half_height, map_half_width - text_half_width );
|
|
|
|
// Inset by a little to account for position display.
|
|
radius -= 8.f;
|
|
|
|
text_box->setOrigin(
|
|
llround(map_half_width - text_half_width + radius * cos( rotation )),
|
|
llround(map_half_height - text_half_height + radius * sin( rotation )) );
|
|
}
|
|
|
|
void LLFloaterMap::updateMinorDirections()
|
|
{
|
|
if (mTextBoxNorthEast == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Hide minor directions if they cover too much of the map
|
|
bool show_minors = mTextBoxNorthEast->getRect().getHeight() < MAP_MINOR_DIR_THRESHOLD *
|
|
llmin(getRect().getWidth(), getRect().getHeight());
|
|
|
|
mTextBoxNorthEast->setVisible(show_minors);
|
|
mTextBoxNorthWest->setVisible(show_minors);
|
|
mTextBoxSouthWest->setVisible(show_minors);
|
|
mTextBoxSouthEast->setVisible(show_minors);
|
|
}
|
|
|
|
// virtual
|
|
void LLFloaterMap::draw()
|
|
{
|
|
F32 rotation = 0;
|
|
|
|
static LLUICachedControl<bool> rotate_map("MiniMapRotate", true);
|
|
if( rotate_map )
|
|
{
|
|
// rotate subsequent draws to agent rotation
|
|
rotation = atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
|
|
}
|
|
|
|
setDirectionPos( mTextBoxEast, rotation );
|
|
setDirectionPos( mTextBoxNorth, rotation + F_PI_BY_TWO );
|
|
setDirectionPos( mTextBoxWest, rotation + F_PI );
|
|
setDirectionPos( mTextBoxSouth, rotation + F_PI + F_PI_BY_TWO );
|
|
|
|
setDirectionPos( mTextBoxNorthEast, rotation + F_PI_BY_TWO / 2);
|
|
setDirectionPos( mTextBoxNorthWest, rotation + F_PI_BY_TWO + F_PI_BY_TWO / 2);
|
|
setDirectionPos( mTextBoxSouthWest, rotation + F_PI + F_PI_BY_TWO / 2);
|
|
setDirectionPos( mTextBoxSouthEast, rotation + F_PI + F_PI_BY_TWO + F_PI_BY_TWO / 2);
|
|
|
|
// Note: we can't just gAgent.check cameraMouselook() because the transition states are wrong.
|
|
if(gAgentCamera.cameraMouselook())
|
|
{
|
|
setMouseOpaque(FALSE);
|
|
getDragHandle()->setMouseOpaque(FALSE);
|
|
}
|
|
else
|
|
{
|
|
setMouseOpaque(TRUE);
|
|
getDragHandle()->setMouseOpaque(TRUE);
|
|
}
|
|
|
|
if (LLTracker::isTracking(0))
|
|
{
|
|
mPopupMenu->setItemEnabled("Stop Tracking", true);
|
|
}
|
|
|
|
// <FS:CR> Aurora Sim
|
|
//LLFloater::draw();
|
|
if(LLWorld::getInstance()->getAllowMinimap())
|
|
{
|
|
LLFloater::draw();
|
|
}
|
|
// <FS:CR> Aurora Sim
|
|
}
|
|
|
|
void LLFloaterMap::stretchMiniMap(S32 width,S32 height)
|
|
{
|
|
//fix for ext-7112
|
|
//by default ctrl can't overlap caption area
|
|
if(mMap)
|
|
{
|
|
LLRect map_rect;
|
|
map_rect.setLeftTopAndSize( MAP_PADDING_LEFT, getRect().getHeight() - MAP_PADDING_TOP, width, height);
|
|
mMap->reshape( width, height, 1);
|
|
mMap->setRect(map_rect);
|
|
}
|
|
}
|
|
|
|
void LLFloaterMap::reshape(S32 width, S32 height, BOOL called_from_parent)
|
|
{
|
|
LLFloater::reshape(width, height, called_from_parent);
|
|
|
|
stretchMiniMap(width - MAP_PADDING_LEFT - MAP_PADDING_RIGHT,
|
|
height - MAP_PADDING_TOP - MAP_PADDING_BOTTOM);
|
|
|
|
updateMinorDirections();
|
|
}
|
|
|
|
void LLFloaterMap::handleZoom(const LLSD& userdata)
|
|
{
|
|
std::string level = userdata.asString();
|
|
|
|
F32 scale = 0.0f;
|
|
|
|
if (level == std::string("default"))
|
|
{
|
|
LLControlVariable *pvar = gSavedSettings.getControl("MiniMapScale");
|
|
if(pvar)
|
|
{
|
|
pvar->resetToDefault();
|
|
scale = gSavedSettings.getF32("MiniMapScale");
|
|
}
|
|
}
|
|
else if (level == std::string("close"))
|
|
scale = LLNetMap::MAP_SCALE_MAX;
|
|
else if (level == std::string("medium"))
|
|
scale = LLNetMap::MAP_SCALE_MID;
|
|
else if (level == std::string("far"))
|
|
scale = LLNetMap::MAP_SCALE_MIN;
|
|
if (scale != 0.0f)
|
|
{
|
|
mMap->setScale(scale);
|
|
}
|
|
}
|
|
|
|
LLFloaterMap* LLFloaterMap::getInstance()
|
|
{
|
|
return LLFloaterReg::getTypedInstance<LLFloaterMap>("mini_map");
|
|
}
|
|
|
|
void LLFloaterMap::setMinimized(BOOL b)
|
|
{
|
|
LLFloater::setMinimized(b);
|
|
if(b)
|
|
{
|
|
setTitle(getString("mini_map_caption"));
|
|
}
|
|
else
|
|
{
|
|
setTitle("");
|
|
}
|
|
}
|
|
|
|
void LLFloaterMap::handleMark(const LLSD& userdata)
|
|
{
|
|
mMap->setAvatarMark(userdata);
|
|
}
|
|
|
|
void LLFloaterMap::handleClearMarks()
|
|
{
|
|
mMap->clearAvatarMarks();
|
|
}
|
|
|
|
void LLFloaterMap::handleCam()
|
|
{
|
|
mMap->camAvatar();
|
|
}
|
|
|
|
void LLFloaterMap::handleStopTracking (const LLSD& userdata)
|
|
{
|
|
if (mPopupMenu)
|
|
{
|
|
mPopupMenu->setItemEnabled ("Stop Tracking", false);
|
|
LLTracker::stopTracking ((void*)(ptrdiff_t)LLTracker::isTracking(NULL));
|
|
}
|
|
}
|
|
|
|
// <FS:Ansariel> Avatar tracking feature
|
|
void LLFloaterMap::handleStartTracking()
|
|
{
|
|
mMap->startTracking();
|
|
}
|
|
// </FS:Ansariel> Avatar tracking feature
|
|
|
|
// <FS:CR> FIXME: Cut and paste duplicate code from llnetmap.cpp
|
|
void LLFloaterMap::setAvatarProfileLabel(const LLAvatarName& avName, const std::string& item_name)
|
|
{
|
|
LLMenuItemGL* pItem = mPopupMenu->findChild<LLMenuItemGL>(item_name, TRUE /*recurse*/);
|
|
if (pItem)
|
|
{
|
|
pItem->setLabel(avName.getCompleteName());
|
|
pItem->getMenu()->arrange();
|
|
}
|
|
}
|
|
|
|
void LLFloaterMap::handleOverlayToggle(const LLSD& sdParam)
|
|
{
|
|
// Toggle the setting
|
|
const std::string strControl = sdParam.asString();
|
|
BOOL fCurValue = gSavedSettings.getBOOL(strControl);
|
|
gSavedSettings.setBOOL(strControl, !fCurValue);
|
|
|
|
// Force an overlay update
|
|
refreshParcelOverlay();
|
|
}
|
|
|
|
void LLFloaterMap::handleShowProfile(const LLSD& sdParam) const
|
|
{
|
|
const std::string strParam = sdParam.asString();
|
|
if ("closest" == strParam)
|
|
{
|
|
LLAvatarActions::showProfile(mMap->mClosestAgentRightClick);
|
|
}
|
|
else if ("place" == strParam)
|
|
{
|
|
LLSD sdParams;
|
|
sdParams["type"] = "remote_place";
|
|
sdParams["x"] = mMap->mPosGlobalRightClick.mdV[VX];
|
|
sdParams["y"] = mMap->mPosGlobalRightClick.mdV[VY];
|
|
sdParams["z"] = mMap->mPosGlobalRightClick.mdV[VZ];
|
|
|
|
if (gSavedSettings.getBOOL("FSUseStandalonePlaceDetailsFloater"))
|
|
{
|
|
LLFloaterReg::showInstance("fs_placedetails", sdParams);
|
|
}
|
|
else
|
|
{
|
|
LLFloaterSidePanelContainer::showPanel("places", sdParams);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool LLFloaterMap::checkTextureType(const LLSD& sdParam) const
|
|
{
|
|
const std::string strParam = sdParam.asString();
|
|
|
|
bool fWorldMapTextures = gSavedSettings.getBOOL("MiniMapWorldMapTextures");
|
|
if ("maptile" == strParam)
|
|
return fWorldMapTextures;
|
|
else if ("terrain" == strParam)
|
|
return !fWorldMapTextures;
|
|
return false;
|
|
}
|
|
|
|
void LLFloaterMap::handleTextureType(const LLSD& sdParam) const
|
|
{
|
|
gSavedSettings.setBOOL("MiniMapWorldMapTextures", ("maptile" == sdParam.asString()));
|
|
}
|
|
|
|
void LLFloaterMap::refreshParcelOverlay()
|
|
{
|
|
mMap->mUpdateParcelImage = true;
|
|
}
|