1 files changed, 234 insertions, 29 deletions

diff --git a/linden/indra/newview/llnetmap.cpp b/linden/indra/newview/llnetmap.cpp
index 5a54068..b8bf0cb 100644
--- a/linden/indra/newview/llnetmap.cpp
+++ b/linden/indra/newview/llnetmap.cpp
@@ -45,8 +45,10 @@
 #include "llcolorscheme.h"
 #include "llviewercontrol.h"
 #include "llfloateravatarinfo.h"
+#include "llfloatermap.h"
 #include "llfloaterworldmap.h"
 #include "llframetimer.h"
+#include "llmutelist.h"
 #include "lltracker.h"
 #include "llmenugl.h"
 #include "llsurface.h"
@@ -76,6 +78,8 @@ const F32 MAP_MINOR_DIR_THRESHOLD = 0.08f;
 const F32 MIN_DOT_RADIUS = 3.5f;
 const F32 DOT_SCALE = 0.75f;
 const F32 MIN_PICK_SCALE = 2.f;
+const S32 SLOP = 2;
+const S32 TRACKING_RADIUS = 3;
 
 LLNetMap::LLNetMap(const std::string& name) :
         LLPanel(name),
@@ -96,6 +100,11 @@ LLNetMap::LLNetMap(const std::string& name) :
         
         // Register event listeners for popup menu
         (new LLScaleMap())->registerListener(this, "MiniMap.ZoomLevel");
+        (new LLCenterMap())->registerListener(this, "MiniMap.Center");
+        (new LLCheckCenterMap())->registerListener(this, "MiniMap.CheckCenter");
+        (new LLRotateMap())->registerListener(this, "MiniMap.Rotate");
+        (new LLCheckRotateMap())->registerListener(this, "MiniMap.CheckRotate");
+        (new LLShowWorldMap())->registerListener(this, "MiniMap.ShowWorldMap");
         (new LLStopTracking())->registerListener(this, "MiniMap.StopTracking");
         (new LLEnableTracking())->registerListener(this, "MiniMap.EnableTracking");
         (new LLShowAgentProfile())->registerListener(this, "MiniMap.ShowProfile");
@@ -114,6 +123,11 @@ LLNetMap::LLNetMap(const std::string& name) :
         mPopupMenuHandle = menu->getHandle();
 }
 
+BOOL LLNetMap::postBuild()
+{
+        return TRUE;
+}
+
 LLNetMap::~LLNetMap()
 {
 }
@@ -163,8 +177,11 @@ void LLNetMap::draw()
                 createObjectImage();
         }
 
-        mCurPanX = lerp(mCurPanX, mTargetPanX, LLCriticalDamp::getInterpolant(0.1f));
-        mCurPanY = lerp(mCurPanY, mTargetPanY, LLCriticalDamp::getInterpolant(0.1f));
+        if (gSavedSettings.getS32( "MiniMapCenter" ) != MAP_CENTER_NONE)
+        {
+                mCurPanX = lerp(mCurPanX, mTargetPanX, LLCriticalDamp::getInterpolant(0.1f));
+                mCurPanY = lerp(mCurPanY, mTargetPanY, LLCriticalDamp::getInterpolant(0.1f));
+        }
 
         F32 rotation = 0;
 
@@ -264,26 +281,24 @@ void LLNetMap::draw()
                         }
                         gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
                 }
-                
-
-                LLVector3d old_center = mObjectImageCenterGlobal;
-                LLVector3d new_center = gAgent.getCameraPositionGlobal();
-
-                new_center.mdV[0] = (5.f/mObjectMapTPM)*floor(0.2f*mObjectMapTPM*new_center.mdV[0]);
-                new_center.mdV[1] = (5.f/mObjectMapTPM)*floor(0.2f*mObjectMapTPM*new_center.mdV[1]);
-                new_center.mdV[2] = 0.f;
 
+                // Redraw object layer periodically
                 if (mUpdateNow || (map_timer.getElapsedTimeF32() > 0.5f))
                 {
                         mUpdateNow = FALSE;
-                        mObjectImageCenterGlobal = new_center;
 
-                        // Center moved enough.
+                        // Locate the centre of the object layer, accounting for panning
+                        LLVector3 new_center = globalPosToView(gAgent.getCameraPositionGlobal(), rotate_map);   
+                        new_center.mV[0] -= mCurPanX;
+                        new_center.mV[1] -= mCurPanY;
+                        new_center.mV[2] = 0.f;
+                        mObjectImageCenterGlobal = viewPosToGlobal(llround(new_center.mV[0]), llround(new_center.mV[1]), rotate_map);
+
                         // Create the base texture.
                         U8 *default_texture = mObjectRawImagep->getData();
                         memset( default_texture, 0, mObjectImagep->getWidth() * mObjectImagep->getHeight() * mObjectImagep->getComponents() );
 
-                        // Draw buildings
+                        // Draw objects
                         gObjectList.renderObjectsForMap(*this);
 
                         mObjectImagep->setSubImage(mObjectRawImagep, 0, 0, mObjectImagep->getWidth(), mObjectImagep->getHeight());
@@ -327,6 +342,10 @@ void LLNetMap::draw()
                 // Draw avatars
                 LLColor4 avatar_color = gColors.getColor( "MapAvatar" );
                 LLColor4 friend_color = gColors.getColor( "MapFriend" );
+                LLColor4 muted_color = gColors.getColor( "MapMuted" );
+                LLColor4 selected_color = gColors.getColor( "MapSelected" );
+                LLColor4 glyph_color;
+
                 std::vector<LLUUID> avatar_ids;
                 std::vector<LLVector3d> positions;
                 LLWorld::getInstance()->getAvatars(&avatar_ids, &positions);
@@ -335,10 +354,37 @@ void LLNetMap::draw()
                         // TODO: it'd be very cool to draw these in sorted order from lowest Z to highest.
                         // just be careful to sort the avatar IDs along with the positions. -MG
                         pos_map = globalPosToView(positions[i], rotate_map);
+                        
+                        if (LLFloaterMap::getSelected() == avatar_ids[i])
+                        {
+                                glyph_color = selected_color;
+                        }
+                        // Show them muted even if they're friends
+                        else if (LLMuteList::getInstance()->isMuted(avatar_ids[i]))
+                        {
+                                glyph_color = muted_color;
+                        }
+                        else if (is_agent_friend(avatar_ids[i]))
+                        {
+                                glyph_color = friend_color;
+                        }
+                        else
+                        {
+                                glyph_color = avatar_color;
+                        }
+
+// [RLVa:KB]
+                        if ( rlv_handler_t::isEnabled() && !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES) )
+                        {
+                                // User is not allowed to see who it is, or even if it's a friend,
+                                // due to RLV settings.
+                                glyph_color = avatar_color;
+                        }
+// [/RLVa:KB]
 
                         LLWorldMapView::drawAvatar(
                                 pos_map.mV[VX], pos_map.mV[VY], 
-                                is_agent_friend(avatar_ids[i]) ? friend_color : avatar_color, 
+                                glyph_color, 
                                 pos_map.mV[VZ],
                                 mDotRadius);
 
@@ -435,6 +481,8 @@ void LLNetMap::draw()
         setDirectionPos( getChild<LLTextBox>("se_label"), rotation + F_PI + F_PI_BY_TWO + F_PI_BY_TWO / 2);
 
         LLView::draw();
+
+        LLFloaterMap::updateRadar();
 }
 
 void LLNetMap::reshape(S32 width, S32 height, BOOL called_from_parent)
@@ -540,11 +588,39 @@ BOOL LLNetMap::handleToolTip( S32 x, S32 y, std::string& msg, LLRect* sticky_rec
                 std::string fullname;
                 if(mClosestAgentToCursor.notNull() && gCacheName->getFullName(mClosestAgentToCursor, fullname))
                 {
-                        msg.append(fullname);
-                        msg.append("\n");
+// [RLVa:KB]
+                        if ( rlv_handler_t::isEnabled() && !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES) )
+                        {
+                                // User is not allowed to see who it is, due to RLV settings.
+                                msg.append(rlv_handler_t::cstrHidden);
+                        }
+                        else
+                        {
+                                msg.append(fullname);
+                                msg.append("\n");
+                        }
+// [/RLVa:KB]
+                }
+                
+// [RLVa:KB]
+                if (rlv_handler_t::isEnabled() && !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
+                {
+                        // User is not allowed to see where they are, due to RLV settings.
+                        msg.append( rlv_handler_t::cstrHidden ); 
+                }
+                else
+                {
+                        msg.append( region->getName() );
                 }
-                msg.append( region->getName() );
+// [/RLVa:KB]
 
+
+                msg.append("\n");
+                gSavedSettings.getBOOL( "MiniMapTeleport" ) ?
+                                                msg.append(getString("tooltip_tp")) : msg.append(getString("tooltip_map"));
+                msg.append("\n");
+                msg.append(getString("tooltip_pan"));
+                
 #ifndef LL_RELEASE_FOR_DOWNLOAD
                 std::string buffer;
                 msg.append("\n");
@@ -554,13 +630,6 @@ BOOL LLNetMap::handleToolTip( S32 x, S32 y, std::string& msg, LLRect* sticky_rec
                 buffer = region->getHost().getString();
                 msg.append(buffer);
 #endif
-                // *TODO: 
-                //      - put this under the control of XUI so it can be translated.
-
-                if ( gSavedSettings.getBOOL( "MiniMapTeleport" ))
-                        msg.append("\n(Double-click to teleport)");
-                else
-                        msg.append("\n(Double-click to open Map)");
 
                 S32 SLOP = 4;
                 localPointToScreen( 
@@ -616,11 +685,7 @@ void LLNetMap::renderScaledPointGlobal( const LLVector3d& pos, const LLColor4U &
         LLVector3 local_pos;
         local_pos.setVec( pos - mObjectImageCenterGlobal );
 
-        // DEV-17370 - megaprims of size > 4096 cause lag.  (go figger.)
-        const F32 MAX_RADIUS = 256.0f;
-        F32 radius_clamped = llmin(radius_meters, MAX_RADIUS);
-        
-        S32 diameter_pixels = llround(2 * radius_clamped * mObjectMapTPM);
+        S32 diameter_pixels = llround(2 * radius_meters * mObjectMapTPM);
         renderPoint( local_pos, color, diameter_pixels );
 }
 
@@ -740,6 +805,98 @@ void LLNetMap::createObjectImage()
         mUpdateNow = TRUE;
 }
 
+BOOL LLNetMap::handleMouseDown( S32 x, S32 y, MASK mask )
+{
+        if (!(mask & MASK_SHIFT)) return FALSE;
+
+        // Start panning
+        gFocusMgr.setMouseCapture( this );
+
+        mMouseDownPanX = llround(mCurPanX);
+        mMouseDownPanY = llround(mCurPanY);
+        mMouseDownX = x;
+        mMouseDownY = y;
+        return TRUE;
+}
+
+BOOL LLNetMap::handleMouseUp( S32 x, S32 y, MASK mask )
+{
+        if (hasMouseCapture())
+        {
+                if (mPanning)
+                {
+                        // restore mouse cursor
+                        S32 local_x, local_y;
+                        local_x = mMouseDownX + llfloor(mCurPanX - mMouseDownPanX);
+                        local_y = mMouseDownY + llfloor(mCurPanY - mMouseDownPanY);
+                        LLRect clip_rect = getRect();
+                        clip_rect.stretch(-8);
+                        clip_rect.clipPointToRect(mMouseDownX, mMouseDownY, local_x, local_y);
+                        LLUI::setCursorPositionLocal(this, local_x, local_y);
+
+                        // finish the pan
+                        mPanning = FALSE;
+
+                        mMouseDownX = 0;
+                        mMouseDownY = 0;
+
+                        // auto centre
+                        mTargetPanX = 0;
+                        mTargetPanY = 0;
+                }
+                gViewerWindow->showCursor();
+                gFocusMgr.setMouseCapture( NULL );
+                return TRUE;
+        }
+        return FALSE;
+}
+
+// static
+BOOL LLNetMap::outsideSlop(S32 x, S32 y, S32 start_x, S32 start_y)
+{
+        S32 dx = x - start_x;
+        S32 dy = y - start_y;
+
+        return (dx <= -SLOP || SLOP <= dx || dy <= -SLOP || SLOP <= dy);
+}
+
+BOOL LLNetMap::handleHover( S32 x, S32 y, MASK mask )
+{
+        if (hasMouseCapture())
+        {
+                if (mPanning || outsideSlop(x, y, mMouseDownX, mMouseDownY))
+                {
+                        // just started panning, so hide cursor
+                        if (!mPanning)
+                        {
+                                mPanning = TRUE;
+                                gViewerWindow->hideCursor();
+                        }
+
+                        F32 delta_x = (F32)(gViewerWindow->getCurrentMouseDX());
+                        F32 delta_y = (F32)(gViewerWindow->getCurrentMouseDY());
+
+                        // Set pan to value at start of drag + offset
+                        mCurPanX += delta_x;
+                        mCurPanY += delta_y;
+                        mTargetPanX = mCurPanX;
+                        mTargetPanY = mCurPanY;
+
+                        gViewerWindow->moveCursorToCenter();
+                }
+
+                // Doesn't matter, cursor should be hidden
+        gViewerWindow->setCursor( UI_CURSOR_CROSS );
+                return TRUE;
+        }
+        else
+        {
+        gViewerWindow->setCursor( UI_CURSOR_CROSS );
+                lldebugst(LLERR_USER_INPUT) << "hover handled by LLNetMap" << llendl;
+                return TRUE;
+        }
+}
+
 BOOL LLNetMap::handleDoubleClick( S32 x, S32 y, MASK mask )
 {
         if (gSavedSettings.getBOOL( "MiniMapTeleport" ))
@@ -792,6 +949,54 @@ bool LLNetMap::LLScaleMap::handleEvent(LLPointer<LLEvent> event, const LLSD& use
         return true;
 }
 
+bool LLNetMap::LLRotateMap::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        BOOL rotate = gSavedSettings.getBOOL("MiniMapRotate");
+        gSavedSettings.setBOOL("MiniMapRotate", !rotate);
+
+        return true;
+}
+
+bool LLNetMap::LLCheckRotateMap::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        LLNetMap *self = mPtr;
+        BOOL enabled = gSavedSettings.getBOOL("MiniMapRotate");
+        self->findControl(userdata["control"].asString())->setValue(enabled);
+        return true;
+}
+
+bool LLNetMap::LLCenterMap::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        S32 center = userdata.asInteger();
+
+        if (gSavedSettings.getS32("MiniMapCenter") == center)
+        {
+                gSavedSettings.setS32("MiniMapCenter", MAP_CENTER_NONE);
+        }
+        else
+        {
+                gSavedSettings.setS32("MiniMapCenter", userdata.asInteger());
+        }
+
+        return true;
+}
+
+bool LLNetMap::LLCheckCenterMap::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        LLNetMap *self = mPtr;
+        EMiniMapCenter center = (EMiniMapCenter)userdata["data"].asInteger();
+        BOOL enabled = (gSavedSettings.getS32("MiniMapCenter") == center);
+
+        self->findControl(userdata["control"].asString())->setValue(enabled);
+        return true;
+}
+
+bool LLNetMap::LLShowWorldMap::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        LLFloaterWorldMap::show(NULL, FALSE);
+        return true;
+}
+
 bool LLNetMap::LLStopTracking::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
 {
         LLTracker::stopTracking(NULL);