Second Life viewer sources 1.23.0-RC

1 files changed, 196 insertions, 206 deletions

diff --git a/linden/indra/newview/llnetmap.cpp b/linden/indra/newview/llnetmap.cpp
index c96754f..2eee54d 100644
--- a/linden/indra/newview/llnetmap.cpp
+++ b/linden/indra/newview/llnetmap.cpp
@@ -18,7 +18,8 @@
  * There are special exceptions to the terms and conditions of the GPL as
  * it is applied to this Source Code. View the full text of the exception
  * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -44,22 +45,20 @@
 #include "llcallingcard.h"
 #include "llcolorscheme.h"
 #include "llviewercontrol.h"
+#include "llfloateravatarinfo.h"
 #include "llfloaterworldmap.h"
-#include "llfloatermap.h"
 #include "llframetimer.h"
 #include "lltracker.h"
 #include "llmenugl.h"
-#include "llstatgraph.h"
 #include "llsurface.h"
 #include "lltextbox.h"
+#include "lluictrlfactory.h"
 #include "lluuid.h"
 #include "llviewercamera.h"
 #include "llviewerimage.h"
 #include "llviewerimagelist.h"
 #include "llviewermenu.h"
 #include "llviewerobjectlist.h"
-#include "llviewermenu.h"
-#include "llviewerparceloverlay.h"
 #include "llviewerregion.h"
 #include "llviewerwindow.h"
 #include "llvoavatar.h"
@@ -73,19 +72,14 @@ const F32 MAP_SCALE_MIN = 64;
 const F32 MAP_SCALE_MID = 172;
 const F32 MAP_SCALE_MAX = 512;
 const F32 MAP_SCALE_INCREMENT = 16;
+const F32 MAP_MIN_PICK_DIST = 4;
+const F32 MAP_MINOR_DIR_THRESHOLD = 0.08f;
 
 const S32 TRACKING_RADIUS = 3;
 
-//static
-BOOL LLNetMap::sRotateMap = FALSE;
-LLNetMap* LLNetMap::sInstance = NULL;
-
-LLNetMap::LLNetMap(
-        const std::string& name,
-        const LLRect& rect,
-        const LLColor4& bg_color )
-        :
-        LLUICtrl(name, rect, FALSE, NULL, NULL), mBackgroundColor( bg_color ),
+LLNetMap::LLNetMap(const std::string& name) :
+        LLPanel(name),
+        mScale(128.f),
         mObjectMapTPM(1.f),
         mObjectMapPixels(255.f),
         mTargetPanX( 0.f ),
@@ -94,106 +88,57 @@ LLNetMap::LLNetMap(
         mCurPanY( 0.f ),
         mUpdateNow( FALSE )
 {
-        mPixelsPerMeter = gMiniMapScale / REGION_WIDTH_METERS;
-
-        LLNetMap::sRotateMap = gSavedSettings.getBOOL( "MiniMapRotate" );
-        
-        // Surface texture is dynamically generated/updated.
-//      createObjectImage();
+        mScale = gSavedSettings.getF32("MiniMapScale");
+        mPixelsPerMeter = mScale / LLWorld::getInstance()->getRegionWidthInMeters();
 
         mObjectImageCenterGlobal = gAgent.getCameraPositionGlobal();
         
-        // TODO: exteralize hardcoded constants.
-        const S32 DIR_WIDTH = 10;
-        const S32 DIR_HEIGHT = 10;
-        LLRect major_dir_rect(  0, DIR_HEIGHT, DIR_WIDTH, 0 );
-        const LLColor4 minor_color( 1.f, 1.f, 1.f, .7f );
-        const LLRect minor_dir_rect(  0, DIR_HEIGHT, DIR_WIDTH * 2, 0 );
-
-        // Note: removing special treatment for north compass point (DEV-10559). -MG
-        //mTextBoxNorth = new LLTextBox( "N", major_dir_rect );
-        //mTextBoxNorth->setFontStyle(LLFontGL::DROP_SHADOW_SOFT);
-        //addChild( mTextBoxNorth );
-        mTextBoxNorth = new LLTextBox( std::string("N"), major_dir_rect );
-        mTextBoxNorth->setColor( minor_color );
-        addChild( mTextBoxNorth );
-        
-        mTextBoxEast =  new LLTextBox( std::string("E"), major_dir_rect );
-        mTextBoxEast->setColor( minor_color );
-        addChild( mTextBoxEast );
-        
-        major_dir_rect.mRight += 1 ;
-        mTextBoxWest =  new LLTextBox( std::string("W"), major_dir_rect );
-        mTextBoxWest->setColor( minor_color );
-        addChild( mTextBoxWest );
-        major_dir_rect.mRight -= 1 ;
-
-        mTextBoxSouth = new LLTextBox( std::string("S"), major_dir_rect );
-        mTextBoxSouth->setColor( minor_color );
-        addChild( mTextBoxSouth );
-
-        mTextBoxSouthEast =     new LLTextBox( std::string("SE"), minor_dir_rect );
-        mTextBoxSouthEast->setColor( minor_color );
-        addChild( mTextBoxSouthEast );
-        
-        mTextBoxNorthEast = new LLTextBox( std::string("NE"), minor_dir_rect );
-        mTextBoxNorthEast->setColor( minor_color );
-        addChild( mTextBoxNorthEast );
-        
-        mTextBoxSouthWest =     new LLTextBox( std::string("SW"), minor_dir_rect );
-        mTextBoxSouthWest->setColor( minor_color );
-        addChild( mTextBoxSouthWest );
-
-        mTextBoxNorthWest = new LLTextBox( std::string("NW"), minor_dir_rect );
-        mTextBoxNorthWest->setColor( minor_color );
-        addChild( mTextBoxNorthWest );
-
-        // Right-click menu
-        LLMenuGL* menu;
-        menu = new LLMenuGL(std::string("popup"));
-        menu->setCanTearOff(FALSE);
-        menu->append(new LLMenuItemCallGL(std::string("Zoom Close"), handleZoomLevel,
-                                                                                NULL, (void*)2) );
-        menu->append(new LLMenuItemCallGL(std::string("Zoom Medium"), handleZoomLevel,
-                                                                                NULL, (void*)1) );
-        menu->append(new LLMenuItemCallGL(std::string("Zoom Far"), handleZoomLevel,
-                                                                                NULL, (void*)0) );
-        menu->appendSeparator();
-        menu->append(new LLMenuItemCallGL(std::string("Stop Tracking"), &LLTracker::stopTracking,
-                                                                                &LLTracker::isTracking, NULL) );
+        // Register event listeners for popup menu
+        (new LLScaleMap())->registerListener(this, "MiniMap.ZoomLevel");
+        (new LLStopTracking())->registerListener(this, "MiniMap.StopTracking");
+        (new LLEnableTracking())->registerListener(this, "MiniMap.EnableTracking");
+        (new LLShowAgentProfile())->registerListener(this, "MiniMap.ShowProfile");
+        (new LLEnableProfile())->registerListener(this, "MiniMap.EnableProfile");
+
+        LLUICtrlFactory::getInstance()->buildPanel(this, "panel_mini_map.xml");
+
+        updateMinorDirections();
+
+        LLMenuGL* menu = LLUICtrlFactory::getInstance()->buildMenu("menu_mini_map.xml", this);
+        if (!menu)
+        {
+                menu = new LLMenuGL(LLStringUtil::null);
+        }
         menu->setVisible(FALSE);
-        addChild(menu);
         mPopupMenuHandle = menu->getHandle();
-
-        sInstance = this;
 }
 
 LLNetMap::~LLNetMap()
 {
-        sInstance = NULL;
 }
 
 void LLNetMap::setScale( F32 scale )
 {
-        gMiniMapScale = scale;
-        if (gMiniMapScale == 0.f)
+        mScale = scale;
+        if (mScale == 0.f)
         {
-                gMiniMapScale = 0.1f;
+                mScale = 0.1f;
         }
+        gSavedSettings.setF32("MiniMapScale", mScale);
 
         if (mObjectImagep.notNull())
         {
-                F32 half_width = (F32)(getRect().getWidth() / 2);
-                F32 half_height = (F32)(getRect().getHeight() / 2);
-                F32 radius = sqrt( half_width * half_width + half_height * half_height );
-                F32 region_widths = (2.f*radius)/gMiniMapScale;
+                F32 width = (F32)(getRect().getWidth());
+                F32 height = (F32)(getRect().getHeight());
+                F32 diameter = sqrt(width * width + height * height);
+                F32 region_widths = diameter / mScale;
                 F32 meters = region_widths * LLWorld::getInstance()->getRegionWidthInMeters();
                 F32 num_pixels = (F32)mObjectImagep->getWidth();
-                mObjectMapTPM = num_pixels/meters;
-                mObjectMapPixels = 2.f*radius;
+                mObjectMapTPM = num_pixels / meters;
+                mObjectMapPixels = diameter;
         }
 
-        mPixelsPerMeter = gMiniMapScale / REGION_WIDTH_METERS;
+        mPixelsPerMeter = mScale / LLWorld::getInstance()->getRegionWidthInMeters();
 
         mUpdateNow = TRUE;
 }
@@ -215,16 +160,16 @@ void LLNetMap::draw()
         {
                 createObjectImage();
         }
-        
+
         mCurPanX = lerp(mCurPanX, mTargetPanX, LLCriticalDamp::getInterpolant(0.1f));
         mCurPanY = lerp(mCurPanY, mTargetPanY, LLCriticalDamp::getInterpolant(0.1f));
 
-        // Prepare a scissor region
         F32 rotation = 0;
 
+        // Prepare a scissor region
         {
                 LLGLEnable scissor(GL_SCISSOR_TEST);
-                
+
                 {
                         gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                         LLLocalClipRect clip(getLocalRect());
@@ -232,8 +177,11 @@ void LLNetMap::draw()
                         glMatrixMode(GL_MODELVIEW);
 
                         // Draw background rectangle
-                        gGL.color4fv( mBackgroundColor.mV );
-                        gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0);
+                        if(isBackgroundVisible())
+                        {
+                                gGL.color4fv(isBackgroundOpaque() ? getBackgroundColor().mV : getTransparentColor().mV);
+                                gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0);
+                        }
                 }
 
                 // region 0,0 is in the middle
@@ -244,7 +192,8 @@ void LLNetMap::draw()
 
                 gGL.translatef( (F32) center_sw_left, (F32) center_sw_bottom, 0.f);
 
-                if( LLNetMap::sRotateMap )
+                BOOL rotate_map = gSavedSettings.getBOOL( "MiniMapRotate" );
+                if( rotate_map )
                 {
                         // rotate subsequent draws to agent rotation
                         rotation = atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
@@ -253,35 +202,30 @@ void LLNetMap::draw()
 
                 // figure out where agent is
                 S32 region_width = llround(LLWorld::getInstance()->getRegionWidthInMeters());
+                LLColor4 this_region_color = gColors.getColor( "NetMapThisRegion" );
+                LLColor4 live_region_color = gColors.getColor( "NetMapLiveRegion" );
+                LLColor4 dead_region_color = gColors.getColor( "NetMapDeadRegion" );
 
-                for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->mActiveRegionList.begin();
-                         iter != LLWorld::getInstance()->mActiveRegionList.end(); ++iter)
+                for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
+                         iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
                 {
                         LLViewerRegion* regionp = *iter;
                         // Find x and y position relative to camera's center.
                         LLVector3 origin_agent = regionp->getOriginAgent();
                         LLVector3 rel_region_pos = origin_agent - gAgent.getCameraPositionAgent();
-                        F32 relative_x = (rel_region_pos.mV[0] / region_width) * gMiniMapScale;
-                        F32 relative_y = (rel_region_pos.mV[1] / region_width) * gMiniMapScale;
+                        F32 relative_x = (rel_region_pos.mV[0] / region_width) * mScale;
+                        F32 relative_y = (rel_region_pos.mV[1] / region_width) * mScale;
 
                         // background region rectangle
                         F32 bottom =    relative_y;
                         F32 left =              relative_x;
-                        F32 top =               bottom + gMiniMapScale ;
-                        F32 right =             left + gMiniMapScale ;
-
-                        if (regionp == gAgent.getRegion())
-                        {
-                                gGL.color4f(1.f, 1.f, 1.f, 1.f);
-                        }
-                        else
-                        {
-                                gGL.color4f(0.8f, 0.8f, 0.8f, 1.f);
-                        }
+                        F32 top =               bottom + mScale ;
+                        F32 right =             left + mScale ;
 
+                        gGL.color4fv(regionp == gAgent.getRegion() ? this_region_color.mV : live_region_color.mV);
                         if (!regionp->isAlive())
                         {
-                                gGL.color4f(1.f, 0.5f, 0.5f, 1.f);
+                                gGL.color4fv(dead_region_color.mV);
                         }
 
 
@@ -347,8 +291,8 @@ void LLNetMap::draw()
 
                 LLVector3 map_center_agent = gAgent.getPosAgentFromGlobal(mObjectImageCenterGlobal);
                 map_center_agent -= gAgent.getCameraPositionAgent();
-                map_center_agent.mV[VX] *= gMiniMapScale/region_width;
-                map_center_agent.mV[VY] *= gMiniMapScale/region_width;
+                map_center_agent.mV[VX] *= mScale/region_width;
+                map_center_agent.mV[VY] *= mScale/region_width;
 
                 gGL.getTexUnit(0)->bind(mObjectImagep);
                 F32 image_half_width = 0.5f*mObjectMapPixels;
@@ -370,81 +314,67 @@ void LLNetMap::draw()
                 LLVector3d pos_global;
                 LLVector3 pos_map;
 
+                // Mouse pointer in local coordinates
+                S32 local_mouse_x;
+                S32 local_mouse_y;
+                LLUI::getCursorPositionLocal(this, &local_mouse_x, &local_mouse_y);
+                mClosestAgentToCursor.setNull();
+                F32 closest_dist = F32_MAX;
+
                 // Draw avatars
-                for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->mActiveRegionList.begin();
-                         iter != LLWorld::getInstance()->mActiveRegionList.end(); ++iter)
+                LLColor4 avatar_color = gColors.getColor( "MapAvatar" );
+                LLColor4 friend_color = gColors.getColor( "MapFriend" );
+                std::vector<LLUUID> avatar_ids;
+                std::vector<LLVector3d> positions;
+                LLWorld::getInstance()->getAvatars(&avatar_ids, &positions);
+                for(U32 i=0; i<avatar_ids.size(); i++)
                 {
-                        LLViewerRegion* regionp = *iter;
-                        const LLVector3d& origin_global = regionp->getOriginGlobal();
-
-                        S32 count = regionp->mMapAvatars.count();
-                        S32 i;
-                        LLVector3 pos_local;
-                        U32 compact_local;
-                        U8 bits;
                         // 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
-                        for (i = 0; i < count; i++)
-                        {
-                                compact_local = regionp->mMapAvatars.get(i);
-
-                                bits = compact_local & 0xFF;
-                                pos_local.mV[VZ] = F32(bits) * 4.f;
-                                compact_local >>= 8;
-
-                                bits = compact_local & 0xFF;
-                                pos_local.mV[VY] = (F32)bits;
-                                compact_local >>= 8;
-
-                                bits = compact_local & 0xFF;
-                                pos_local.mV[VX] = (F32)bits;
+                        pos_map = globalPosToView(positions[i], rotate_map);
 
-                                pos_global.setVec( pos_local );
-                                pos_global += origin_global;
+                        LLWorldMapView::drawAvatar(
+                                pos_map.mV[VX], pos_map.mV[VY], 
+                                is_agent_friend(avatar_ids[i]) ? friend_color : avatar_color, 
+                                pos_map.mV[VZ]);
 
-                                pos_map = globalPosToView(pos_global);
-
-                                BOOL show_as_friend = FALSE;
-                                if( i < regionp->mMapAvatarIDs.count())
-                                {
-                                        show_as_friend = is_agent_friend(regionp->mMapAvatarIDs.get(i));
-                                }
-                                LLWorldMapView::drawAvatar(
-                                        pos_map.mV[VX], pos_map.mV[VY], 
-                                        show_as_friend ? gFriendMapColor : gAvatarMapColor, 
-                                        pos_map.mV[VZ]);
+                        F32     dist_to_cursor = dist_vec(LLVector2(pos_map.mV[VX], pos_map.mV[VY]), LLVector2(local_mouse_x,local_mouse_y));
+                        if(dist_to_cursor < MAP_MIN_PICK_DIST && dist_to_cursor < closest_dist)
+                        {
+                                closest_dist = dist_to_cursor;
+                                mClosestAgentToCursor = avatar_ids[i];
                         }
                 }
 
                 // Draw dot for autopilot target
                 if (gAgent.getAutoPilot())
                 {
-                        drawTracking( gAgent.getAutoPilotTargetGlobal(), gTrackColor );
+                        drawTracking( gAgent.getAutoPilotTargetGlobal(), rotate_map, gTrackColor );
                 }
                 else
                 {
                         LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus();
                         if (  LLTracker::TRACKING_AVATAR == tracking_status )
                         {
-                                drawTracking( LLAvatarTracker::instance().getGlobalPos(), gTrackColor );
+                                drawTracking( LLAvatarTracker::instance().getGlobalPos(), rotate_map, gTrackColor );
                         } 
                         else if ( LLTracker::TRACKING_LANDMARK == tracking_status 
                                         || LLTracker::TRACKING_LOCATION == tracking_status )
                         {
-                                drawTracking( LLTracker::getTrackedPositionGlobal(), gTrackColor );
+                                drawTracking( LLTracker::getTrackedPositionGlobal(), rotate_map, gTrackColor );
                         }
                 }
 
                 // Draw dot for self avatar position
                 pos_global = gAgent.getPositionGlobal();
-                pos_map = globalPosToView(pos_global);
+                pos_map = globalPosToView(pos_global, rotate_map);
                 LLUIImagePtr you = LLWorldMapView::sAvatarYouSmallImage;
                 you->draw(
                         llround(pos_map.mV[VX]) - you->getWidth()/2, 
                         llround(pos_map.mV[VY]) - you->getHeight()/2);
 
                 // Draw frustum
-                F32 meters_to_pixels = gMiniMapScale/ LLWorld::getInstance()->getRegionWidthInMeters();
+                F32 meters_to_pixels = mScale/ LLWorld::getInstance()->getRegionWidthInMeters();
 
                 F32 horiz_fov = LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect();
                 F32 far_clip_meters = LLViewerCamera::getInstance()->getFar();
@@ -459,9 +389,9 @@ void LLNetMap::draw()
 
                 gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
-                if( LLNetMap::sRotateMap )
+                if( rotate_map )
                 {
-                        gGL.color4fv(gFrustumMapColor.mV);
+                        gGL.color4fv(gColors.getColor("NetMapFrustum").mV);
 
                         gGL.begin( LLRender::TRIANGLES  );
                                 gGL.vertex2f( ctr_x, ctr_y );
@@ -471,7 +401,7 @@ void LLNetMap::draw()
                 }
                 else
                 {
-                        gGL.color4fv(gRotatingFrustumMapColor.mV);
+                        gGL.color4fv(gColors.getColor("NetMapFrustumRotating").mV);
                         
                         // If we don't rotate the map, we have to rotate the frustum.
                         gGL.pushMatrix();
@@ -487,21 +417,26 @@ void LLNetMap::draw()
         }
         
         // Rotation of 0 means that North is up
-        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( getChild<LLTextBox>("e_label"), rotation);
+        setDirectionPos( getChild<LLTextBox>("n_label"), rotation + F_PI_BY_TWO);
+        setDirectionPos( getChild<LLTextBox>("w_label"), rotation + F_PI);
+        setDirectionPos( getChild<LLTextBox>("s_label"), 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);
+        setDirectionPos( getChild<LLTextBox>("ne_label"), rotation + F_PI_BY_TWO / 2);
+        setDirectionPos( getChild<LLTextBox>("nw_label"), rotation + F_PI_BY_TWO + F_PI_BY_TWO / 2);
+        setDirectionPos( getChild<LLTextBox>("sw_label"), rotation + F_PI + F_PI_BY_TWO / 2);
+        setDirectionPos( getChild<LLTextBox>("se_label"), rotation + F_PI + F_PI_BY_TWO + F_PI_BY_TWO / 2);
 
-        LLUICtrl::draw();
+        LLView::draw();
 }
 
-LLVector3 LLNetMap::globalPosToView( const LLVector3d& global_pos )
+void LLNetMap::reshape(S32 width, S32 height, BOOL called_from_parent)
 {
+        LLPanel::reshape(width, height, called_from_parent);
+        updateMinorDirections();
+}
+
+LLVector3 LLNetMap::globalPosToView( const LLVector3d& global_pos, BOOL rotated ){
         LLVector3d relative_pos_global = global_pos - gAgent.getCameraPositionGlobal();
         LLVector3 pos_local;
         pos_local.setVec(relative_pos_global);  // convert to floats from doubles
@@ -510,7 +445,7 @@ LLVector3 LLNetMap::globalPosToView( const LLVector3d& global_pos )
         pos_local.mV[VY] *= mPixelsPerMeter;
         // leave Z component in meters
 
-        if( LLNetMap::sRotateMap )
+        if( rotated )
         {
                 F32 radians = atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
                 LLQuaternion rot(radians, LLVector3(0.f, 0.f, 1.f));
@@ -523,10 +458,10 @@ LLVector3 LLNetMap::globalPosToView( const LLVector3d& global_pos )
         return pos_local;
 }
 
-void LLNetMap::drawTracking(const LLVector3d& pos_global, const LLColor4& color, 
-                                                        BOOL draw_arrow )
+void LLNetMap::drawTracking(const LLVector3d& pos_global, BOOL rotated,
+                                                        const LLColor4& color, BOOL draw_arrow )
 {
-        LLVector3 pos_local = globalPosToView( pos_global );
+        LLVector3 pos_local = globalPosToView( pos_global, rotated );
         if( (pos_local.mV[VX] < 0) ||
                 (pos_local.mV[VY] < 0) ||
                 (pos_local.mV[VX] >= getRect().getWidth()) ||
@@ -549,22 +484,22 @@ void LLNetMap::drawTracking(const LLVector3d& pos_global, const LLColor4& color,
         }
 }
 
-LLVector3d LLNetMap::viewPosToGlobal( S32 x, S32 y )
+LLVector3d LLNetMap::viewPosToGlobal( S32 x, S32 y, BOOL rotated )
 {
         x -= llround(getRect().getWidth() / 2 + mCurPanX);
         y -= llround(getRect().getHeight() / 2 + mCurPanY);
 
-        LLVector3 pos_local( (F32)x, (F32)y, 0 );
+        LLVector3 pos_local( (F32)x, (F32)y, 0.f );
 
         F32 radians = - atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
 
-        if( LLNetMap::sRotateMap )
+        if( rotated )
         {
                 LLQuaternion rot(radians, LLVector3(0.f, 0.f, 1.f));
                 pos_local.rotVec( rot );
         }
 
-        pos_local *= ( LLWorld::getInstance()->getRegionWidthInMeters() / gMiniMapScale );
+        pos_local *= ( LLWorld::getInstance()->getRegionWidthInMeters() / mScale );
         
         LLVector3d pos_global;
         pos_global.setVec( pos_local );
@@ -576,7 +511,7 @@ LLVector3d LLNetMap::viewPosToGlobal( S32 x, S32 y )
 BOOL LLNetMap::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
         // note that clicks are reversed from what you'd think
-        setScale(llclamp(gMiniMapScale - clicks*MAP_SCALE_INCREMENT, MAP_SCALE_MIN, MAP_SCALE_MAX));
+        setScale(llclamp(mScale - clicks*MAP_SCALE_INCREMENT, MAP_SCALE_MIN, MAP_SCALE_MAX));
         return TRUE;
 }
 
@@ -587,10 +522,17 @@ BOOL LLNetMap::handleToolTip( S32 x, S32 y, std::string& msg, LLRect* sticky_rec
         {
                 return FALSE;
         }
-        LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( viewPosToGlobal( x, y ) );
+        LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( viewPosToGlobal( x, y , gSavedSettings.getBOOL( "MiniMapRotate" )) );
         if( region )
         {
-                msg.assign( region->getName() );
+                msg.assign("");
+                std::string fullname;
+                if(mClosestAgentToCursor.notNull() && gCacheName->getFullName(mClosestAgentToCursor, fullname))
+                {
+                        msg.append(fullname);
+                        msg.append("\n");
+                }
+                msg.append( region->getName() );
 
 #ifndef LL_RELEASE_FOR_DOWNLOAD
                 std::string buffer;
@@ -601,9 +543,8 @@ 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.
-                msg.append("\n(Double-click to open Map)");
+                msg.append("\n");
+                msg.append(getToolTip());
 
                 S32 SLOP = 4;
                 localPointToScreen( 
@@ -611,8 +552,12 @@ BOOL LLNetMap::handleToolTip( S32 x, S32 y, std::string& msg, LLRect* sticky_rec
                         &(sticky_rect_screen->mLeft), &(sticky_rect_screen->mBottom) );
                 sticky_rect_screen->mRight = sticky_rect_screen->mLeft + 2 * SLOP;
                 sticky_rect_screen->mTop = sticky_rect_screen->mBottom + 2 * SLOP;
+                handled = TRUE;
+        }
+        if(!handled)
+        {
+                return LLPanel::handleToolTip(x, y, msg, sticky_rect_screen);
         }
-        handled = TRUE;
         return handled;
 }
 
@@ -622,19 +567,32 @@ void LLNetMap::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);
-        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 );
+        F32 half_height = (F32)( (getRect().getHeight() - text_box->getRect().getHeight()) / 2);
+        F32 half_width  = (F32)( (getRect().getWidth() - text_box->getRect().getWidth()) / 2);
+        F32 radius = llmin( half_height, 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 )) );
+        text_box->setOrigin(llround(half_width  + radius * cos( rotation )),
+                                                llround(half_height + radius * sin( rotation )));
+}
+
+void LLNetMap::updateMinorDirections()
+{
+        if (getChild<LLTextBox>("ne_label") == NULL)
+        {
+                return;
+        }
+
+        // Hide minor directions if they cover too much of the map
+        bool show_minors = getChild<LLTextBox>("ne_label")->getRect().getHeight() < MAP_MINOR_DIR_THRESHOLD *
+                        llmin(getRect().getWidth(), getRect().getHeight());
+
+        getChild<LLTextBox>("ne_label")->setVisible(show_minors);
+        getChild<LLTextBox>("nw_label")->setVisible(show_minors);
+        getChild<LLTextBox>("sw_label")->setVisible(show_minors);
+        getChild<LLTextBox>("se_label")->setVisible(show_minors);
 }
 
 void LLNetMap::renderScaledPointGlobal( const LLVector3d& pos, const LLColor4U &color, F32 radius_meters )
@@ -739,10 +697,10 @@ void LLNetMap::renderPoint(const LLVector3 &pos_local, const LLColor4U &color,
 void LLNetMap::createObjectImage()
 {
         // Find the size of the side of a square that surrounds the circle that surrounds getRect().
-        F32 half_width = (F32)(getRect().getWidth() / 2);
-        F32 half_height = (F32)(getRect().getHeight() / 2);
-        F32 radius = sqrt( half_width * half_width + half_height * half_height );
-        S32 square_size = S32( 2 * radius );
+        // ... which is, the diagonal of the rect.
+        F32 width = getRect().getWidth();
+        F32 height = getRect().getHeight();
+        S32 square_size = llround( sqrt(width*width + height*height) );
 
         // Find the least power of two >= the minimum size.
         const S32 MIN_SIZE = 32;
@@ -761,7 +719,7 @@ void LLNetMap::createObjectImage()
                 U8* data = mObjectRawImagep->getData();
                 memset( data, 0, img_size * img_size * 4 );
                 mObjectImagep = new LLImageGL( mObjectRawImagep, FALSE);
-                setScale(gMiniMapScale);
+                setScale(mScale);
         }
         mUpdateNow = TRUE;
 }
@@ -774,6 +732,7 @@ BOOL LLNetMap::handleDoubleClick( S32 x, S32 y, MASK mask )
 
 BOOL LLNetMap::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
+        mClosestAgentAtLastRightClick = mClosestAgentToCursor;
         LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
         if (menu)
         {
@@ -786,22 +745,53 @@ BOOL LLNetMap::handleRightMouseDown(S32 x, S32 y, MASK mask)
 
 
 // static
-void LLNetMap::handleZoomLevel(void* which)
+bool LLNetMap::LLScaleMap::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
 {
-        intptr_t level = (intptr_t)which;
+        LLNetMap *self = mPtr;
+
+        S32 level = userdata.asInteger();
 
         switch(level)
         {
         case 0:
-                LLNetMap::sInstance->setScale(MAP_SCALE_MIN);
+                self->setScale(MAP_SCALE_MIN);
                 break;
         case 1:
-                LLNetMap::sInstance->setScale(MAP_SCALE_MID);
+                self->setScale(MAP_SCALE_MID);
                 break;
         case 2:
-                LLNetMap::sInstance->setScale(MAP_SCALE_MAX);
+                self->setScale(MAP_SCALE_MAX);
                 break;
         default:
                 break;
         }
+
+        return true;
+}
+
+bool LLNetMap::LLStopTracking::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        LLTracker::stopTracking(NULL);
+        return true;
+}
+
+bool LLNetMap::LLEnableTracking::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        LLNetMap *self = mPtr;
+        self->findControl(userdata["control"].asString())->setValue(LLTracker::isTracking(NULL));
+        return true;
+}
+
+bool LLNetMap::LLShowAgentProfile::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        LLNetMap *self = mPtr;
+        LLFloaterAvatarInfo::show(self->mClosestAgentAtLastRightClick);
+        return true;
+}
+
+bool LLNetMap::LLEnableProfile::handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+{
+        LLNetMap *self = mPtr;
+        self->findControl(userdata["control"].asString())->setValue(self->isAgentUnderCursor());
+        return true;
 }