开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llfloaterworldmap.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：41k
源码类别：

游戏引擎

开发平台：

C++ Builder

llfloaterworldmap.cpp：源码内容
  1. /** 
  2.  * @file llfloaterworldmap.cpp
  3.  * @author James Cook, Tom Yedwab
  4.  * @brief LLFloaterWorldMap class implementation
  5.  *
  6.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2003-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. /*
  35.  * Map of the entire world, with multiple background images,
  36.  * avatar tracking, teleportation by double-click, etc.
  37.  */
  39. #include "llviewerprecompiledheaders.h"
  41. #include "llfloaterworldmap.h"
  43. #include "llagent.h"
  44. #include "llbutton.h"
  45. #include "llcallingcard.h"
  46. #include "llcombobox.h"
  47. #include "llviewercontrol.h"
  48. #include "llcommandhandler.h"
  49. #include "lldraghandle.h"
  50. //#include "llfirstuse.h"
  51. #include "llfloaterreg.h" // getTypedInstance()
  52. #include "llfocusmgr.h"
  53. #include "llinventorymodel.h"
  54. #include "llinventoryobserver.h"
  55. #include "lllandmarklist.h"
  56. #include "lllineeditor.h"
  57. #include "llnotificationsutil.h"
  58. #include "llregionhandle.h"
  59. #include "llscrolllistctrl.h"
  60. #include "llslurl.h"
  61. #include "lltextbox.h"
  62. #include "lltracker.h"
  63. #include "lltrans.h"
  64. #include "llviewerinventory.h" // LLViewerInventoryItem
  65. #include "llviewermenu.h"
  66. #include "llviewerregion.h"
  67. #include "llviewerstats.h"
  68. #include "llviewertexture.h"
  69. #include "llworldmap.h"
  70. #include "llworldmapmessage.h"
  71. #include "llworldmapview.h"
  72. #include "lluictrlfactory.h"
  73. #include "llappviewer.h"
  74. #include "llmapimagetype.h"
  75. #include "llweb.h"
  76. #include "llslider.h"
  77. #include "message.h"
  79. #include "llwindow.h" // copyTextToClipboard()
  81. //---------------------------------------------------------------------------
  82. // Constants
  83. //---------------------------------------------------------------------------
  84. static const F32 MAP_ZOOM_TIME = 0.2f;
  86. // Merov: we switched from using the "world size" (which varies depending where the user went) to a fixed
  87. // width of 512 regions max visible at a time. This makes the zoom slider works in a consistent way across
  88. // sessions and doesn't prevent the user to pan the world if it was to grow a lot beyond that limit.
  89. // Currently (01/26/09), this value allows the whole grid to be visible in a 1024x1024 window.
  90. static const S32 MAX_VISIBLE_REGIONS = 512;
  92. enum EPanDirection
  93. {
  94. PAN_UP,
  95. PAN_DOWN,
  96. PAN_LEFT,
  97. PAN_RIGHT
  98. };
  100. // Values in pixels per region
  101. static const F32 ZOOM_MAX = 128.f;
  103. //---------------------------------------------------------------------------
  104. // Globals
  105. //---------------------------------------------------------------------------
  107. // handle secondlife:///app/worldmap/{NAME}/{COORDS} URLs
  108. class LLWorldMapHandler : public LLCommandHandler
  109. {
  110. public:
  111. // requires trusted browser to trigger
  112. LLWorldMapHandler() : LLCommandHandler("worldmap", UNTRUSTED_THROTTLE) { }
  114. bool handle(const LLSD& params, const LLSD& query_map,
  115. LLMediaCtrl* web)
  116. {
  117. if (params.size() == 0)
  118. {
  119. // support the secondlife:///app/worldmap SLapp
  120. LLFloaterReg::showInstance("world_map", "center");
  121. return true;
  122. }
  124. // support the secondlife:///app/worldmap/{LOCATION}/{COORDS} SLapp
  125. const std::string region_name = params[0].asString();
  126. S32 x = (params.size() > 1) ? params[1].asInteger() : 128;
  127. S32 y = (params.size() > 2) ? params[2].asInteger() : 128;
  128. S32 z = (params.size() > 3) ? params[3].asInteger() : 0;
  130. LLFloaterWorldMap::getInstance()->trackURL(region_name, x, y, z);
  131. LLFloaterReg::showInstance("world_map", "center");
  133. return true;
  134. }
  135. };
  136. LLWorldMapHandler gWorldMapHandler;
  139. LLFloaterWorldMap* gFloaterWorldMap = NULL;
  141. class LLMapInventoryObserver : public LLInventoryObserver
  142. {
  143. public:
  144. LLMapInventoryObserver() {}
  145. virtual ~LLMapInventoryObserver() {}
  146. virtual void changed(U32 mask);
  147. };
  148.   
  149. void LLMapInventoryObserver::changed(U32 mask)
  150. {
  151. // if there's a change we're interested in.
  152. if((mask & (LLInventoryObserver::CALLING_CARD | LLInventoryObserver::ADD |
  153. LLInventoryObserver::REMOVE)) != 0)
  154. {
  155. gFloaterWorldMap->inventoryChanged();
  156. }
  157. }
  159. class LLMapFriendObserver : public LLFriendObserver
  160. {
  161. public:
  162. LLMapFriendObserver() {}
  163. virtual ~LLMapFriendObserver() {}
  164. virtual void changed(U32 mask);
  165. };
  167. void LLMapFriendObserver::changed(U32 mask)
  168. {
  169. // if there's a change we're interested in.
  170. if((mask & (LLFriendObserver::ADD | LLFriendObserver::REMOVE | LLFriendObserver::ONLINE | LLFriendObserver::POWERS)) != 0)
  171. {
  172. gFloaterWorldMap->friendsChanged();
  173. }
  174. }
  176. //---------------------------------------------------------------------------
  177. // Statics
  178. //---------------------------------------------------------------------------
  180. // Used as a pretend asset and inventory id to mean "landmark at my home location."
  181. const LLUUID LLFloaterWorldMap::sHomeID( "10000000-0000-0000-0000-000000000001" );
  183. //---------------------------------------------------------------------------
  184. // Construction and destruction
  185. //---------------------------------------------------------------------------
  188. LLFloaterWorldMap::LLFloaterWorldMap(const LLSD& key)
  189. : LLFloater(key),
  190. mInventory(NULL),
  191. mInventoryObserver(NULL),
  192. mFriendObserver(NULL),
  193. mCompletingRegionName(),
  194. mCompletingRegionPos(),
  195. mWaitingForTracker(FALSE),
  196. mIsClosing(FALSE),
  197. mSetToUserPosition(TRUE),
  198. mTrackedLocation(0,0,0),
  199. mTrackedStatus(LLTracker::TRACKING_NOTHING)
  200. {
  201. gFloaterWorldMap = this;
  203. mFactoryMap["objects_mapview"] = LLCallbackMap(createWorldMapView, NULL);
  205. //Called from floater reg: LLUICtrlFactory::getInstance()->buildFloater(this, "floater_world_map.xml", FALSE);
  206. mCommitCallbackRegistrar.add("WMap.Location", boost::bind(&LLFloaterWorldMap::onLocationCommit, this));
  207. mCommitCallbackRegistrar.add("WMap.AvatarCombo", boost::bind(&LLFloaterWorldMap::onAvatarComboCommit, this));
  208. mCommitCallbackRegistrar.add("WMap.Landmark", boost::bind(&LLFloaterWorldMap::onLandmarkComboCommit, this));
  209. mCommitCallbackRegistrar.add("WMap.SearchResult", boost::bind(&LLFloaterWorldMap::onCommitSearchResult, this));
  210. mCommitCallbackRegistrar.add("WMap.GoHome", boost::bind(&LLFloaterWorldMap::onGoHome, this));
  211. mCommitCallbackRegistrar.add("WMap.Teleport", boost::bind(&LLFloaterWorldMap::onClickTeleportBtn, this));
  212. mCommitCallbackRegistrar.add("WMap.ShowTarget", boost::bind(&LLFloaterWorldMap::onShowTargetBtn, this));
  213. mCommitCallbackRegistrar.add("WMap.ShowAgent", boost::bind(&LLFloaterWorldMap::onShowAgentBtn, this));
  214. mCommitCallbackRegistrar.add("WMap.Clear", boost::bind(&LLFloaterWorldMap::onClearBtn, this));
  215. mCommitCallbackRegistrar.add("WMap.CopySLURL", boost::bind(&LLFloaterWorldMap::onCopySLURL, this));
  216. }
  218. // static
  219. void* LLFloaterWorldMap::createWorldMapView(void* data)
  220. {
  221. return new LLWorldMapView();
  222. }
  224. BOOL LLFloaterWorldMap::postBuild()
  225. {
  226. mPanel = getChild<LLPanel>("objects_mapview");
  228. LLComboBox *avatar_combo = getChild<LLComboBox>("friend combo");
  229. if (avatar_combo)
  230. {
  231. avatar_combo->selectFirstItem();
  232. avatar_combo->setPrearrangeCallback( boost::bind(&LLFloaterWorldMap::onAvatarComboPrearrange, this) );
  233. avatar_combo->setTextEntryCallback( boost::bind(&LLFloaterWorldMap::onComboTextEntry, this) );
  234. }
  236. getChild<LLScrollListCtrl>("location")->setFocusChangedCallback(boost::bind(&LLFloaterWorldMap::onLocationFocusChanged, this, _1));
  238. LLLineEditor *location_editor = getChild<LLLineEditor>("location");
  239. if (location_editor)
  240. {
  241. location_editor->setKeystrokeCallback( boost::bind(&LLFloaterWorldMap::onSearchTextEntry, this, _1), NULL );
  242. }
  244. getChild<LLScrollListCtrl>("search_results")->setDoubleClickCallback( boost::bind(&LLFloaterWorldMap::onClickTeleportBtn, this));
  246. LLComboBox *landmark_combo = getChild<LLComboBox>( "landmark combo");
  247. if (landmark_combo)
  248. {
  249. landmark_combo->selectFirstItem();
  250. landmark_combo->setPrearrangeCallback( boost::bind(&LLFloaterWorldMap::onLandmarkComboPrearrange, this) );
  251. landmark_combo->setTextEntryCallback( boost::bind(&LLFloaterWorldMap::onComboTextEntry, this) );
  252. }
  254. mCurZoomVal = log(LLWorldMapView::sMapScale)/log(2.f);
  255. childSetValue("zoom slider", LLWorldMapView::sMapScale);
  257. setDefaultBtn(NULL);
  259. mZoomTimer.stop();
  261. return TRUE;
  262. }
  264. // virtual
  265. LLFloaterWorldMap::~LLFloaterWorldMap()
  266. {
  267. // All cleaned up by LLView destructor
  268. mPanel = NULL;
  270. // Inventory deletes all observers on shutdown
  271. mInventory = NULL;
  272. mInventoryObserver = NULL;
  274. // avatar tracker will delete this for us.
  275. mFriendObserver = NULL;
  277. gFloaterWorldMap = NULL;
  278. }
  280. //static
  281. LLFloaterWorldMap* LLFloaterWorldMap::getInstance()
  282. {
  283. return LLFloaterReg::getTypedInstance<LLFloaterWorldMap>("world_map");
  284. }
  286. // virtual
  287. void LLFloaterWorldMap::onClose(bool app_quitting)
  288. {
  289. // While we're not visible, discard the overlay images we're using
  290. LLWorldMap::getInstance()->clearImageRefs();
  291. }
  293. // virtual
  294. void LLFloaterWorldMap::onOpen(const LLSD& key)
  295. {
  296. bool center_on_target = (key.asString() == "center");
  298. mIsClosing = FALSE;
  300. LLWorldMapView* map_panel;
  301. map_panel = (LLWorldMapView*)gFloaterWorldMap->mPanel;
  302. map_panel->clearLastClick();
  304. {
  305. // reset pan on show, so it centers on you again
  306. if (!center_on_target)
  307. {
  308. LLWorldMapView::setPan(0, 0, TRUE);
  309. }
  310. map_panel->updateVisibleBlocks();
  312. // Reload items as they may have changed
  313. LLWorldMap::getInstance()->reloadItems();
  315. // We may already have a bounding box for the regions of the world,
  316. // so use that to adjust the view.
  317. adjustZoomSliderBounds();
  319. // Could be first show
  320. //LLFirstUse::useMap();
  322. // Start speculative download of landmarks
  323. const LLUUID landmark_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
  324. gInventory.startBackgroundFetch(landmark_folder_id);
  326. childSetFocus("location", TRUE);
  327. gFocusMgr.triggerFocusFlash();
  329. buildAvatarIDList();
  330. buildLandmarkIDLists();
  332. // If nothing is being tracked, set flag so the user position will be found
  333. mSetToUserPosition = ( LLTracker::getTrackingStatus() == LLTracker::TRACKING_NOTHING );
  334. }
  336. if (center_on_target)
  337. {
  338. centerOnTarget(FALSE);
  339. }
  340. }
  344. // static
  345. void LLFloaterWorldMap::reloadIcons(void*)
  346. {
  347. LLWorldMap::getInstance()->reloadItems();
  348. }
  350. // virtual
  351. BOOL LLFloaterWorldMap::handleHover(S32 x, S32 y, MASK mask)
  352. {
  353. BOOL handled;
  354. handled = LLFloater::handleHover(x, y, mask);
  355. return handled;
  356. }
  358. BOOL LLFloaterWorldMap::handleScrollWheel(S32 x, S32 y, S32 clicks)
  359. {
  360. if (!isMinimized() && isFrontmost())
  361. {
  362. LLRect area;
  363. childGetRect("search_results", area);
  364. if(!area.pointInRect(x, y))
  365. {
  366. F32 slider_value = (F32)childGetValue("zoom slider").asReal();
  367. slider_value += ((F32)clicks * -0.3333f);
  368. childSetValue("zoom slider", LLSD(slider_value));
  369. return TRUE;
  370. }
  371. }
  373. return LLFloater::handleScrollWheel(x, y, clicks);
  374. }
  377. // virtual
  378. void LLFloaterWorldMap::reshape( S32 width, S32 height, BOOL called_from_parent )
  379. {
  380. LLFloater::reshape( width, height, called_from_parent );
  381. }
  384. // virtual
  385. void LLFloaterWorldMap::draw()
  386. {
  387. static LLUIColor map_track_color = LLUIColorTable::instance().getColor("MapTrackColor", LLColor4::white);
  388. static LLUIColor map_track_disabled_color = LLUIColorTable::instance().getColor("MapTrackDisabledColor", LLColor4::white);
  390. // Hide/Show Mature Events controls
  391. childSetVisible("events_mature_icon", gAgent.canAccessMature());
  392. childSetVisible("events_mature_label", gAgent.canAccessMature());
  393. childSetVisible("event_mature_chk", gAgent.canAccessMature());
  395. childSetVisible("events_adult_icon", gAgent.canAccessMature());
  396. childSetVisible("events_adult_label", gAgent.canAccessMature());
  397. childSetVisible("event_adult_chk", gAgent.canAccessMature());
  398. bool adult_enabled = gAgent.canAccessAdult();
  399. if (!adult_enabled)
  400. {
  401. childSetValue("event_adult_chk", FALSE);
  402. }
  403. childSetEnabled("event_adult_chk", adult_enabled);
  405. // On orientation island, users don't have a home location yet, so don't
  406. // let them teleport "home".  It dumps them in an often-crowed welcome
  407. // area (infohub) and they get confused. JC
  408. LLViewerRegion* regionp = gAgent.getRegion();
  409. bool agent_on_prelude = (regionp && regionp->isPrelude());
  410. bool enable_go_home = gAgent.isGodlike() || !agent_on_prelude;
  411. childSetEnabled("Go Home", enable_go_home);
  413. updateLocation();
  415. LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus(); 
  416. if (LLTracker::TRACKING_AVATAR == tracking_status)
  417. {
  418. childSetColor("avatar_icon", map_track_color);
  419. }
  420. else
  421. {
  422. childSetColor("avatar_icon", map_track_disabled_color);
  423. }
  425. if (LLTracker::TRACKING_LANDMARK == tracking_status)
  426. {
  427. childSetColor("landmark_icon", map_track_color);
  428. }
  429. else
  430. {
  431. childSetColor("landmark_icon", map_track_disabled_color);
  432. }
  434. if (LLTracker::TRACKING_LOCATION == tracking_status)
  435. {
  436. childSetColor("location_icon", map_track_color);
  437. }
  438. else
  439. {
  440. if (mCompletingRegionName != "")
  441. {
  442. F64 seconds = LLTimer::getElapsedSeconds();
  443. double value = fmod(seconds, 2);
  444. value = 0.5 + 0.5*cos(value * F_PI);
  445. LLColor4 loading_color(0.0, F32(value/2), F32(value), 1.0);
  446. childSetColor("location_icon", loading_color);
  447. }
  448. else
  449. {
  450. childSetColor("location_icon", map_track_disabled_color);
  451. }
  452. }
  454. // check for completion of tracking data
  455. if (mWaitingForTracker)
  456. {
  457. centerOnTarget(TRUE);
  458. }
  460. childSetEnabled("Teleport", (BOOL)tracking_status);
  461. // childSetEnabled("Clear", (BOOL)tracking_status);
  462. childSetEnabled("Show Destination", (BOOL)tracking_status || LLWorldMap::getInstance()->isTracking());
  463. childSetEnabled("copy_slurl", (mSLURL.size() > 0) );
  465. setMouseOpaque(TRUE);
  466. getDragHandle()->setMouseOpaque(TRUE);
  468. //RN: snaps to zoom value because interpolation caused jitter in the text rendering
  469. if (!mZoomTimer.getStarted() && mCurZoomVal != (F32)childGetValue("zoom slider").asReal())
  470. {
  471. mZoomTimer.start();
  472. }
  473. F32 interp = mZoomTimer.getElapsedTimeF32() / MAP_ZOOM_TIME;
  474. if (interp > 1.f)
  475. {
  476. interp = 1.f;
  477. mZoomTimer.stop();
  478. }
  479. mCurZoomVal = lerp(mCurZoomVal, (F32)childGetValue("zoom slider").asReal(), interp);
  480. F32 map_scale = 256.f*pow(2.f, mCurZoomVal);
  481. LLWorldMapView::setScale( map_scale );
  483. // Enable/disable checkboxes depending on the zoom level
  484. // If above threshold level (i.e. low res) -> Disable all checkboxes
  485. // If under threshold level (i.e. high res) -> Enable all checkboxes
  486. bool enable = LLWorldMapView::showRegionInfo();
  487. childSetEnabled("people_chk", enable);
  488. childSetEnabled("infohub_chk", enable);
  489. childSetEnabled("telehub_chk", enable);
  490. childSetEnabled("land_for_sale_chk", enable);
  491. childSetEnabled("event_chk", enable);
  492. childSetEnabled("event_mature_chk", enable);
  493. childSetEnabled("event_adult_chk", enable);
  495. LLFloater::draw();
  496. }
  499. //-------------------------------------------------------------------------
  500. // Internal utility functions
  501. //-------------------------------------------------------------------------
  504. void LLFloaterWorldMap::trackAvatar( const LLUUID& avatar_id, const std::string& name )
  505. {
  506. LLCtrlSelectionInterface *iface = childGetSelectionInterface("friend combo");
  507. if (!iface) return;
  509. buildAvatarIDList();
  510. if(iface->setCurrentByID(avatar_id) || gAgent.isGodlike())
  511. {
  512. // *HACK: Adjust Z values automatically for liaisons & gods so
  513. // they swoop down when they click on the map. Requested
  514. // convenience.
  515. if(gAgent.isGodlike())
  516. {
  517. childSetValue("spin z", LLSD(200.f));
  518. }
  519. // Don't re-request info if we already have it or we won't have it in time to teleport
  520. if (mTrackedStatus != LLTracker::TRACKING_AVATAR || name != mTrackedAvatarName)
  521. {
  522. mTrackedStatus = LLTracker::TRACKING_AVATAR;
  523. mTrackedAvatarName = name;
  524. LLTracker::trackAvatar(avatar_id, name);
  525. }
  526. }
  527. else
  528. {
  529. LLTracker::stopTracking(NULL);
  530. }
  531. setDefaultBtn("Teleport");
  532. }
  534. void LLFloaterWorldMap::trackLandmark( const LLUUID& landmark_item_id )
  535. {
  536. LLCtrlSelectionInterface *iface = childGetSelectionInterface("landmark combo");
  537. if (!iface) return;
  539. buildLandmarkIDLists();
  540. BOOL found = FALSE;
  541. S32 idx;
  542. for (idx = 0; idx < mLandmarkItemIDList.count(); idx++)
  543. {
  544. if ( mLandmarkItemIDList.get(idx) == landmark_item_id)
  545. {
  546. found = TRUE;
  547. break;
  548. }
  549. }
  551. if (found && iface->setCurrentByID( landmark_item_id ) ) 
  552. {
  553. LLUUID asset_id = mLandmarkAssetIDList.get( idx );
  554. std::string name;
  555. LLComboBox* combo = getChild<LLComboBox>( "landmark combo");
  556. if (combo) name = combo->getSimple();
  557. mTrackedStatus = LLTracker::TRACKING_LANDMARK;
  558. LLTracker::trackLandmark(mLandmarkAssetIDList.get( idx ), // assetID
  559. mLandmarkItemIDList.get( idx ), // itemID
  560. name); // name
  562. if( asset_id != sHomeID )
  563. {
  564. // start the download process
  565. gLandmarkList.getAsset( asset_id);
  566. }
  568. // We have to download both region info and landmark data, so set busy. JC
  569. // getWindow()->incBusyCount();
  570. }
  571. else
  572. {
  573. LLTracker::stopTracking(NULL);
  574. }
  575. setDefaultBtn("Teleport");
  576. }
  579. void LLFloaterWorldMap::trackEvent(const LLItemInfo &event_info)
  580. {
  581. mTrackedStatus = LLTracker::TRACKING_LOCATION;
  582. LLTracker::trackLocation(event_info.getGlobalPosition(), event_info.getName(), event_info.getToolTip(), LLTracker::LOCATION_EVENT);
  583. setDefaultBtn("Teleport");
  584. }
  586. void LLFloaterWorldMap::trackGenericItem(const LLItemInfo &item)
  587. {
  588. mTrackedStatus = LLTracker::TRACKING_LOCATION;
  589. LLTracker::trackLocation(item.getGlobalPosition(), item.getName(), item.getToolTip(), LLTracker::LOCATION_ITEM);
  590. setDefaultBtn("Teleport");
  591. }
  593. void LLFloaterWorldMap::trackLocation(const LLVector3d& pos_global)
  594. {
  595. LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromPosGlobal(pos_global);
  596. if (!sim_info)
  597. {
  598. // We haven't found a region for that point yet, leave the tracking to the world map
  599. LLWorldMap::getInstance()->setTracking(pos_global);
  600. LLTracker::stopTracking(NULL);
  601. S32 world_x = S32(pos_global.mdV[0] / 256);
  602. S32 world_y = S32(pos_global.mdV[1] / 256);
  603. LLWorldMapMessage::getInstance()->sendMapBlockRequest(world_x, world_y, world_x, world_y, true);
  604. setDefaultBtn("");
  605. return;
  606. }
  607. if (sim_info->isDown())
  608. {
  609. // Down region. Show the blue circle of death!
  610. // i.e. let the world map that this and tell it it's invalid
  611. LLWorldMap::getInstance()->setTracking(pos_global);
  612. LLWorldMap::getInstance()->setTrackingInvalid();
  613. LLTracker::stopTracking(NULL);
  614. setDefaultBtn("");
  615. return;
  616. }
  618. std::string sim_name = sim_info->getName();
  619. F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS );
  620. F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS );
  621. std::string full_name = llformat("%s (%d, %d, %d)", 
  622.   sim_name.c_str(), 
  623.   llround(region_x), 
  624.   llround(region_y),
  625.   llround((F32)pos_global.mdV[VZ]));
  627. std::string tooltip("");
  628. mTrackedStatus = LLTracker::TRACKING_LOCATION;
  629. LLTracker::trackLocation(pos_global, full_name, tooltip);
  630. LLWorldMap::getInstance()->cancelTracking(); // The floater is taking over the tracking
  632. setDefaultBtn("Teleport");
  633. }
  635. void LLFloaterWorldMap::updateLocation()
  636. {
  637. bool gotSimName;
  639. LLTracker::ETrackingStatus status = LLTracker::getTrackingStatus();
  641. // These values may get updated by a message, so need to check them every frame
  642. // The fields may be changed by the user, so only update them if the data changes
  643. LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
  644. if (pos_global.isExactlyZero())
  645. {
  646. LLVector3d agentPos = gAgent.getPositionGlobal();
  648. // Set to avatar's current postion if nothing is selected
  649. if ( status == LLTracker::TRACKING_NOTHING && mSetToUserPosition )
  650. {
  651. // Make sure we know where we are before setting the current user position
  652. std::string agent_sim_name;
  653. gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal( agentPos, agent_sim_name );
  654. if ( gotSimName )
  655. {
  656. mSetToUserPosition = FALSE;
  658. // Fill out the location field
  659. childSetValue("location", agent_sim_name);
  661. // Figure out where user is
  662. LLVector3d agentPos = gAgent.getPositionGlobal();
  664. S32 agent_x = llround( (F32)fmod( agentPos.mdV[VX], (F64)REGION_WIDTH_METERS ) );
  665. S32 agent_y = llround( (F32)fmod( agentPos.mdV[VY], (F64)REGION_WIDTH_METERS ) );
  666. S32 agent_z = llround( (F32)agentPos.mdV[VZ] );
  668. // Set the current SLURL
  669. mSLURL = LLSLURL::buildSLURL(agent_sim_name, agent_x, agent_y, agent_z);
  670. }
  671. }
  673. return; // invalid location
  674. }
  675. std::string sim_name;
  676. gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal( pos_global, sim_name );
  677. if ((status != LLTracker::TRACKING_NOTHING) &&
  678. (status != mTrackedStatus || pos_global != mTrackedLocation || sim_name != mTrackedSimName))
  679. {
  680. mTrackedStatus = status;
  681. mTrackedLocation = pos_global;
  682. mTrackedSimName = sim_name;
  684. if (status == LLTracker::TRACKING_AVATAR)
  685. {
  686. // *HACK: Adjust Z values automatically for liaisons &
  687. // gods so they swoop down when they click on the
  688. // map. Requested convenience.
  689. if(gAgent.isGodlike())
  690. {
  691. pos_global[2] = 200;
  692. }
  693. }
  695. childSetValue("location", sim_name);
  697. F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS );
  698. F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS );
  700. // simNameFromPosGlobal can fail, so don't give the user an invalid SLURL
  701. if ( gotSimName )
  702. {
  703. mSLURL = LLSLURL::buildSLURL(sim_name, llround(region_x), llround(region_y), llround((F32)pos_global.mdV[VZ]));
  704. }
  705. else
  706. { // Empty SLURL will disable the "Copy SLURL to clipboard" button
  707. mSLURL = "";
  708. }
  709. }
  710. }
  712. void LLFloaterWorldMap::trackURL(const std::string& region_name, S32 x_coord, S32 y_coord, S32 z_coord)
  713. {
  714. LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromName(region_name);
  715. z_coord = llclamp(z_coord, 0, 4096);
  716. if (sim_info)
  717. {
  718. LLVector3 local_pos;
  719. local_pos.mV[VX] = (F32)x_coord;
  720. local_pos.mV[VY] = (F32)y_coord;
  721. local_pos.mV[VZ] = (F32)z_coord;
  722. LLVector3d global_pos = sim_info->getGlobalPos(local_pos);
  723. trackLocation(global_pos);
  724. setDefaultBtn("Teleport");
  725. }
  726. else
  727. {
  728. // fill in UI based on URL
  729. gFloaterWorldMap->childSetValue("location", region_name);
  731. // Save local coords to highlight position after region global
  732. // position is returned.
  733. gFloaterWorldMap->mCompletingRegionPos.set(
  734. (F32)x_coord, (F32)y_coord, (F32)z_coord);
  736. // pass sim name to combo box
  737. gFloaterWorldMap->mCompletingRegionName = region_name;
  738. LLWorldMapMessage::getInstance()->sendNamedRegionRequest(region_name);
  739. LLStringUtil::toLower(gFloaterWorldMap->mCompletingRegionName);
  740. LLWorldMap::getInstance()->setTrackingCommit();
  741. }
  742. }
  744. void LLFloaterWorldMap::observeInventory(LLInventoryModel* model)
  745. {
  746. if(mInventory)
  747. {
  748. mInventory->removeObserver(mInventoryObserver);
  749. delete mInventoryObserver;
  750. mInventory = NULL;
  751. mInventoryObserver = NULL;
  752. }
  753. if(model)
  754. {
  755. mInventory = model;
  756. mInventoryObserver = new LLMapInventoryObserver;
  757. // Inventory deletes all observers on shutdown
  758. mInventory->addObserver(mInventoryObserver);
  759. inventoryChanged();
  760. }
  761. }
  763. void LLFloaterWorldMap::inventoryChanged()
  764. {
  765. if(!LLTracker::getTrackedLandmarkItemID().isNull())
  766. {
  767. LLUUID item_id = LLTracker::getTrackedLandmarkItemID();
  768. buildLandmarkIDLists();
  769. trackLandmark(item_id);
  770. }
  771. }
  773. void LLFloaterWorldMap::observeFriends()
  774. {
  775. if(!mFriendObserver)
  776. {
  777. mFriendObserver = new LLMapFriendObserver;
  778. LLAvatarTracker::instance().addObserver(mFriendObserver);
  779. friendsChanged();
  780. }
  781. }
  783. void LLFloaterWorldMap::friendsChanged()
  784. {
  785. LLAvatarTracker& t = LLAvatarTracker::instance();
  786. const LLUUID& avatar_id = t.getAvatarID();
  787. buildAvatarIDList();
  788. if(avatar_id.notNull())
  789. {
  790. LLCtrlSelectionInterface *iface = childGetSelectionInterface("friend combo");
  791. const LLRelationship* buddy_info = t.getBuddyInfo(avatar_id);
  792. if(!iface ||
  793.    !iface->setCurrentByID(avatar_id) || 
  794.    (buddy_info && !buddy_info->isRightGrantedFrom(LLRelationship::GRANT_MAP_LOCATION)) ||
  795.    gAgent.isGodlike())
  796. {
  797. LLTracker::stopTracking(NULL);
  798. }
  799. }
  800. }
  802. // No longer really builds a list.  Instead, just updates mAvatarCombo.
  803. void LLFloaterWorldMap::buildAvatarIDList()
  804. {
  805. LLCtrlListInterface *list = childGetListInterface("friend combo");
  806. if (!list) return;
  808.     // Delete all but the "None" entry
  809. S32 list_size = list->getItemCount();
  810. if (list_size > 1)
  811. {
  812. list->selectItemRange(1, -1);
  813. list->operateOnSelection(LLCtrlListInterface::OP_DELETE);
  814. }
  816. // Get all of the calling cards for avatar that are currently online
  817. LLCollectMappableBuddies collector;
  818. LLAvatarTracker::instance().applyFunctor(collector);
  819. LLCollectMappableBuddies::buddy_map_t::iterator it;
  820. LLCollectMappableBuddies::buddy_map_t::iterator end;
  821. it = collector.mMappable.begin();
  822. end = collector.mMappable.end();
  823. for( ; it != end; ++it)
  824. {
  825. list->addSimpleElement((*it).first, ADD_BOTTOM, (*it).second);
  826. }
  828. list->setCurrentByID( LLAvatarTracker::instance().getAvatarID() );
  829. list->selectFirstItem();
  830. }
  833. void LLFloaterWorldMap::buildLandmarkIDLists()
  834. {
  835. LLCtrlListInterface *list = childGetListInterface("landmark combo");
  836. if (!list) return;
  838.     // Delete all but the "None" entry
  839. S32 list_size = list->getItemCount();
  840. if (list_size > 1)
  841. {
  842. list->selectItemRange(1, -1);
  843. list->operateOnSelection(LLCtrlListInterface::OP_DELETE);
  844. }
  846. mLandmarkItemIDList.reset();
  847. mLandmarkAssetIDList.reset();
  849. // Get all of the current landmarks
  850. mLandmarkAssetIDList.put( LLUUID::null );
  851. mLandmarkItemIDList.put( LLUUID::null );
  853. mLandmarkAssetIDList.put( sHomeID );
  854. mLandmarkItemIDList.put( sHomeID );
  856. LLInventoryModel::cat_array_t cats;
  857. LLInventoryModel::item_array_t items;
  858. LLIsType is_landmark(LLAssetType::AT_LANDMARK);
  859. gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
  860. cats,
  861. items,
  862. LLInventoryModel::EXCLUDE_TRASH,
  863. is_landmark);
  865. std::sort(items.begin(), items.end(), LLViewerInventoryItem::comparePointers());
  867. S32 count = items.count();
  868. for(S32 i = 0; i < count; ++i)
  869. {
  870. LLInventoryItem* item = items.get(i);
  872. list->addSimpleElement(item->getName(), ADD_BOTTOM, item->getUUID());
  874. mLandmarkAssetIDList.put( item->getAssetUUID() );
  875. mLandmarkItemIDList.put( item->getUUID() );
  876. }
  878. list->selectFirstItem();
  879. }
  882. F32 LLFloaterWorldMap::getDistanceToDestination(const LLVector3d &destination, 
  883. F32 z_attenuation) const
  884. {
  885. LLVector3d delta = destination - gAgent.getPositionGlobal();
  886. // by attenuating the z-component we effectively 
  887. // give more weight to the x-y plane
  888. delta.mdV[VZ] *= z_attenuation;
  889. F32 distance = (F32)delta.magVec();
  890. return distance;
  891. }
  894. void LLFloaterWorldMap::clearLocationSelection(BOOL clear_ui)
  895. {
  896. LLCtrlListInterface *list = childGetListInterface("search_results");
  897. if (list)
  898. {
  899. list->operateOnAll(LLCtrlListInterface::OP_DELETE);
  900. }
  901. LLWorldMap::getInstance()->cancelTracking();
  902. mCompletingRegionName = "";
  903. }
  906. void LLFloaterWorldMap::clearLandmarkSelection(BOOL clear_ui)
  907. {
  908. if (clear_ui || !childHasKeyboardFocus("landmark combo"))
  909. {
  910. LLCtrlListInterface *list = childGetListInterface("landmark combo");
  911. if (list)
  912. {
  913. list->selectByValue( "None" );
  914. }
  915. }
  916. }
  919. void LLFloaterWorldMap::clearAvatarSelection(BOOL clear_ui)
  920. {
  921. if (clear_ui || !childHasKeyboardFocus("friend combo"))
  922. {
  923. mTrackedStatus = LLTracker::TRACKING_NOTHING;
  924. LLCtrlListInterface *list = childGetListInterface("friend combo");
  925. if (list)
  926. {
  927. list->selectByValue( "None" );
  928. }
  929. }
  930. }
  933. // Adjust the maximally zoomed out limit of the zoom slider so you
  934. // can see the whole world, plus a little.
  935. void LLFloaterWorldMap::adjustZoomSliderBounds()
  936. {
  937. // Merov: we switched from using the "world size" (which varies depending where the user went) to a fixed
  938. // width of 512 regions max visible at a time. This makes the zoom slider works in a consistent way across
  939. // sessions and doesn't prevent the user to pan the world if it was to grow a lot beyond that limit.
  940. // Currently (01/26/09), this value allows the whole grid to be visible in a 1024x1024 window.
  941. S32 world_width_regions  = MAX_VISIBLE_REGIONS;
  942. S32 world_height_regions = MAX_VISIBLE_REGIONS;
  944. // Find how much space we have to display the world
  945. LLWorldMapView* map_panel;
  946. map_panel = (LLWorldMapView*)mPanel;
  947. LLRect view_rect = map_panel->getRect();
  949. // View size in pixels
  950. S32 view_width = view_rect.getWidth();
  951. S32 view_height = view_rect.getHeight();
  953. // Pixels per region to display entire width/height
  954. F32 width_pixels_per_region = (F32) view_width / (F32) world_width_regions;
  955. F32 height_pixels_per_region = (F32) view_height / (F32) world_height_regions;
  957. F32 pixels_per_region = llmin(width_pixels_per_region,
  958.   height_pixels_per_region);
  960. // Round pixels per region to an even number of slider increments
  961. S32 slider_units = llfloor(pixels_per_region / 0.2f);
  962. pixels_per_region = slider_units * 0.2f;
  964. // Make sure the zoom slider can be moved at least a little bit.
  965. // Likewise, less than the increment pixels per region is just silly.
  966. pixels_per_region = llclamp(pixels_per_region, 1.f, ZOOM_MAX);
  968. F32 min_power = log(pixels_per_region/256.f)/log(2.f);
  970. getChild<LLSlider>("zoom slider")->setMinValue(min_power);
  971. }
  974. //-------------------------------------------------------------------------
  975. // User interface widget callbacks
  976. //-------------------------------------------------------------------------
  978. void LLFloaterWorldMap::onGoHome()
  979. {
  980. gAgent.teleportHome();
  981. closeFloater();
  982. }
  985. void LLFloaterWorldMap::onLandmarkComboPrearrange( )
  986. {
  987. if( mIsClosing )
  988. {
  989. return;
  990. }
  992. LLCtrlListInterface *list = childGetListInterface("landmark combo");
  993. if (!list) return;
  995. LLUUID current_choice = list->getCurrentID();
  997. buildLandmarkIDLists();
  999. if( current_choice.isNull() || !list->setCurrentByID( current_choice ) )
  1000. {
  1001. LLTracker::stopTracking(NULL);
  1002. }
  1004. }
  1006. void LLFloaterWorldMap::onComboTextEntry()
  1007. {
  1008. // Reset the tracking whenever we start typing into any of the search fields,
  1009. // so that hitting <enter> does an auto-complete versus teleporting us to the
  1010. // previously selected landmark/friend.
  1011. LLTracker::clearFocus();
  1012. }
  1014. void LLFloaterWorldMap::onSearchTextEntry( LLLineEditor* ctrl )
  1015. {
  1016. onComboTextEntry();
  1017. updateSearchEnabled();
  1018. }
  1021. void LLFloaterWorldMap::onLandmarkComboCommit()
  1022. {
  1023. if( mIsClosing )
  1024. {
  1025. return;
  1026. }
  1028. LLCtrlListInterface *list = childGetListInterface("landmark combo");
  1029. if (!list) return;
  1031. LLUUID asset_id;
  1032. LLUUID item_id = list->getCurrentID();
  1034. LLTracker::stopTracking(NULL);
  1036. //RN: stopTracking() clears current combobox selection, need to reassert it here
  1037. list->setCurrentByID(item_id);
  1039. if( item_id.isNull() )
  1040. {
  1041. }
  1042. else if( item_id == sHomeID )
  1043. {
  1044. asset_id = sHomeID;
  1045. }
  1046. else
  1047. {
  1048. LLInventoryItem* item = gInventory.getItem( item_id );
  1049. if( item )
  1050. {
  1051. asset_id = item->getAssetUUID();
  1052. }
  1053. else
  1054. {
  1055. // Something went wrong, so revert to a safe value.
  1056. item_id.setNull();
  1057. }
  1058. }
  1060. trackLandmark( item_id);
  1061. onShowTargetBtn();
  1063. // Reset to user postion if nothing is tracked
  1064. mSetToUserPosition = ( LLTracker::getTrackingStatus() == LLTracker::TRACKING_NOTHING );
  1065. }
  1067. // static 
  1068. void LLFloaterWorldMap::onAvatarComboPrearrange( )
  1069. {
  1070. if( mIsClosing )
  1071. {
  1072. return;
  1073. }
  1075. LLCtrlListInterface *list = childGetListInterface("friend combo");
  1076. if (!list) return;
  1078. LLUUID current_choice;
  1080. if( LLAvatarTracker::instance().haveTrackingInfo() )
  1081. {
  1082. current_choice = LLAvatarTracker::instance().getAvatarID();
  1083. }
  1085. buildAvatarIDList();
  1087. if( !list->setCurrentByID( current_choice ) || current_choice.isNull() )
  1088. {
  1089. LLTracker::stopTracking(NULL);
  1090. }
  1091. }
  1093. void LLFloaterWorldMap::onAvatarComboCommit()
  1094. {
  1095. if( mIsClosing )
  1096. {
  1097. return;
  1098. }
  1100. LLCtrlListInterface *list = childGetListInterface("friend combo");
  1101. if (!list) return;
  1103. const LLUUID& new_avatar_id = list->getCurrentID();
  1104. if (new_avatar_id.notNull())
  1105. {
  1106. std::string name;
  1107. LLComboBox* combo = getChild<LLComboBox>("friend combo");
  1108. if (combo) name = combo->getSimple();
  1109. trackAvatar(new_avatar_id, name);
  1110. onShowTargetBtn();
  1111. }
  1112. else
  1113. { // Reset to user postion if nothing is tracked
  1114. mSetToUserPosition = ( LLTracker::getTrackingStatus() == LLTracker::TRACKING_NOTHING );
  1115. }
  1116. }
  1118. void LLFloaterWorldMap::onLocationFocusChanged( LLFocusableElement* focus )
  1119. {
  1120. updateSearchEnabled();
  1121. }
  1123. void LLFloaterWorldMap::updateSearchEnabled()
  1124. {
  1125. if (childHasKeyboardFocus("location") && 
  1126. childGetValue("location").asString().length() > 0)
  1127. {
  1128. setDefaultBtn("DoSearch");
  1129. }
  1130. else
  1131. {
  1132. setDefaultBtn(NULL);
  1133. }
  1134. }
  1136. void LLFloaterWorldMap::onLocationCommit()
  1137. {
  1138. if( mIsClosing )
  1139. {
  1140. return;
  1141. }
  1143. clearLocationSelection(FALSE);
  1144. mCompletingRegionName = "";
  1145. mLastRegionName = "";
  1147. std::string str = childGetValue("location").asString();
  1149. // Trim any leading and trailing spaces in the search target
  1150. std::string saved_str = str;
  1151. LLStringUtil::trim( str );
  1152. if ( str != saved_str )
  1153. { // Set the value in the UI if any spaces were removed
  1154. childSetValue("location", str);
  1155. }
  1157. LLStringUtil::toLower(str);
  1158. mCompletingRegionName = str;
  1159. LLWorldMap::getInstance()->setTrackingCommit();
  1160. if (str.length() >= 3)
  1161. {
  1162. LLWorldMapMessage::getInstance()->sendNamedRegionRequest(str);
  1163. }
  1164. else
  1165. {
  1166. str += "#";
  1167. LLWorldMapMessage::getInstance()->sendNamedRegionRequest(str);
  1168. }
  1169. }
  1171. void LLFloaterWorldMap::onClearBtn()
  1172. {
  1173. mTrackedStatus = LLTracker::TRACKING_NOTHING;
  1174. LLTracker::stopTracking((void *)(intptr_t)TRUE);
  1175. LLWorldMap::getInstance()->cancelTracking();
  1176. mSLURL = ""; // Clear the SLURL since it's invalid
  1177. mSetToUserPosition = TRUE; // Revert back to the current user position
  1178. }
  1180. void LLFloaterWorldMap::onShowTargetBtn()
  1181. {
  1182. centerOnTarget(TRUE);
  1183. }
  1185. void LLFloaterWorldMap::onShowAgentBtn()
  1186. {
  1187. LLWorldMapView::setPan( 0, 0, FALSE); // FALSE == animate
  1188. // Set flag so user's location will be displayed if not tracking anything else
  1189. mSetToUserPosition = TRUE;
  1190. }
  1192. void LLFloaterWorldMap::onClickTeleportBtn()
  1193. {
  1194. teleport();
  1195. }
  1197. void LLFloaterWorldMap::onCopySLURL()
  1198. {
  1199. getWindow()->copyTextToClipboard(utf8str_to_wstring(mSLURL));
  1201. LLSD args;
  1202. args["SLURL"] = mSLURL;
  1204. LLNotificationsUtil::add("CopySLURL", args);
  1205. }
  1207. // protected
  1208. void LLFloaterWorldMap::centerOnTarget(BOOL animate)
  1209. {
  1210. LLVector3d pos_global;
  1211. if(LLTracker::getTrackingStatus() != LLTracker::TRACKING_NOTHING)
  1212. {
  1213. LLVector3d tracked_position = LLTracker::getTrackedPositionGlobal();
  1214. //RN: tracker doesn't allow us to query completion, so we check for a tracking position of
  1215. // absolute zero, and keep trying in the draw loop
  1216. if (tracked_position.isExactlyZero())
  1217. {
  1218. mWaitingForTracker = TRUE;
  1219. return;
  1220. }
  1221. else
  1222. {
  1223. // We've got the position finally, so we're no longer busy. JC
  1224. // getWindow()->decBusyCount();
  1225. pos_global = LLTracker::getTrackedPositionGlobal() - gAgent.getCameraPositionGlobal();
  1226. }
  1227. }
  1228. else if(LLWorldMap::getInstance()->isTracking())
  1229. {
  1230. pos_global = LLWorldMap::getInstance()->getTrackedPositionGlobal() - gAgent.getCameraPositionGlobal();;
  1231. }
  1232. else
  1233. {
  1234. // default behavior = center on agent
  1235. pos_global.clearVec();
  1236. }
  1238. LLWorldMapView::setPan( -llfloor((F32)(pos_global.mdV[VX] * (F64)LLWorldMapView::sMapScale / REGION_WIDTH_METERS)), 
  1239. -llfloor((F32)(pos_global.mdV[VY] * (F64)LLWorldMapView::sMapScale / REGION_WIDTH_METERS)),
  1240. !animate);
  1241. mWaitingForTracker = FALSE;
  1242. }
  1244. // protected
  1245. void LLFloaterWorldMap::fly()
  1246. {
  1247. LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
  1249. // Start the autopilot and close the floater, 
  1250. // so we can see where we're flying
  1251. if (!pos_global.isExactlyZero())
  1252. {
  1253. gAgent.startAutoPilotGlobal( pos_global );
  1254. closeFloater();
  1255. }
  1256. else
  1257. {
  1258. make_ui_sound("UISndInvalidOp");
  1259. }
  1260. }
  1263. // protected
  1264. void LLFloaterWorldMap::teleport()
  1265. {
  1266. BOOL teleport_home = FALSE;
  1267. LLVector3d pos_global;
  1268. LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
  1270. LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus();
  1271. if (LLTracker::TRACKING_AVATAR == tracking_status
  1272. && av_tracker.haveTrackingInfo() )
  1273. {
  1274. pos_global = av_tracker.getGlobalPos();
  1275. pos_global.mdV[VZ] = childGetValue("spin z");
  1276. }
  1277. else if ( LLTracker::TRACKING_LANDMARK == tracking_status)
  1278. {
  1279. if( LLTracker::getTrackedLandmarkAssetID() == sHomeID )
  1280. {
  1281. teleport_home = TRUE;
  1282. }
  1283. else
  1284. {
  1285. LLLandmark* landmark = gLandmarkList.getAsset( LLTracker::getTrackedLandmarkAssetID() );
  1286. LLUUID region_id;
  1287. if(landmark
  1288.    && !landmark->getGlobalPos(pos_global)
  1289.    && landmark->getRegionID(region_id))
  1290. {
  1291. LLLandmark::requestRegionHandle(
  1292. gMessageSystem,
  1293. gAgent.getRegionHost(),
  1294. region_id,
  1295. NULL);
  1296. }
  1297. }
  1298. }
  1299. else if ( LLTracker::TRACKING_LOCATION == tracking_status)
  1300. {
  1301. pos_global = LLTracker::getTrackedPositionGlobal();
  1302. }
  1303. else
  1304. {
  1305. make_ui_sound("UISndInvalidOp");
  1306. }
  1308. // Do the teleport, which will also close the floater
  1309. if (teleport_home)
  1310. {
  1311. gAgent.teleportHome();
  1312. }
  1313. else if (!pos_global.isExactlyZero())
  1314. {
  1315. if(LLTracker::TRACKING_LANDMARK == tracking_status)
  1316. {
  1317. gAgent.teleportViaLandmark(LLTracker::getTrackedLandmarkAssetID());
  1318. }
  1319. else
  1320. {
  1321. gAgent.teleportViaLocation( pos_global );
  1322. }
  1323. }
  1324. }
  1326. void LLFloaterWorldMap::flyToLandmark()
  1327. {
  1328. LLVector3d destination_pos_global;
  1329. if( !LLTracker::getTrackedLandmarkAssetID().isNull() )
  1330. {
  1331. if (LLTracker::hasLandmarkPosition())
  1332. {
  1333. gAgent.startAutoPilotGlobal( LLTracker::getTrackedPositionGlobal() );
  1334. }
  1335. }
  1336. }
  1338. void LLFloaterWorldMap::teleportToLandmark()
  1339. {
  1340. BOOL has_destination = FALSE;
  1341. LLUUID destination_id; // Null means "home"
  1343. if( LLTracker::getTrackedLandmarkAssetID() == sHomeID )
  1344. {
  1345. has_destination = TRUE;
  1346. }
  1347. else
  1348. {
  1349. LLLandmark* landmark = gLandmarkList.getAsset( LLTracker::getTrackedLandmarkAssetID() );
  1350. LLVector3d global_pos;
  1351. if(landmark && landmark->getGlobalPos(global_pos))
  1352. {
  1353. destination_id = LLTracker::getTrackedLandmarkAssetID();
  1354. has_destination = TRUE;
  1355. }
  1356. else if(landmark)
  1357. {
  1358. // pop up an anonymous request request.
  1359. LLUUID region_id;
  1360. if(landmark->getRegionID(region_id))
  1361. {
  1362. LLLandmark::requestRegionHandle(
  1363. gMessageSystem,
  1364. gAgent.getRegionHost(),
  1365. region_id,
  1366. NULL);
  1367. }
  1368. }
  1369. }
  1371. if( has_destination )
  1372. {
  1373. gAgent.teleportViaLandmark( destination_id );
  1374. }
  1375. }
  1378. void LLFloaterWorldMap::teleportToAvatar()
  1379. {
  1380. LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
  1381. if(av_tracker.haveTrackingInfo())
  1382. {
  1383. LLVector3d pos_global = av_tracker.getGlobalPos();
  1384. gAgent.teleportViaLocation( pos_global );
  1385. }
  1386. }
  1389. void LLFloaterWorldMap::flyToAvatar()
  1390. {
  1391. if( LLAvatarTracker::instance().haveTrackingInfo() )
  1392. {
  1393. gAgent.startAutoPilotGlobal( LLAvatarTracker::instance().getGlobalPos() );
  1394. }
  1395. }
  1397. void LLFloaterWorldMap::updateSims(bool found_null_sim)
  1398. {
  1399. if (mCompletingRegionName == "")
  1400. {
  1401. return;
  1402. }
  1404. LLScrollListCtrl *list = getChild<LLScrollListCtrl>("search_results");
  1405. list->operateOnAll(LLCtrlListInterface::OP_DELETE);
  1407. S32 name_length = mCompletingRegionName.length();
  1409. LLSD match;
  1411. S32 num_results = 0;
  1412. std::map<U64, LLSimInfo*>::const_iterator it;
  1413. for (it = LLWorldMap::getInstance()->getRegionMap().begin(); it != LLWorldMap::getInstance()->getRegionMap().end(); ++it)
  1414. {
  1415. LLSimInfo* info = it->second;
  1416. std::string sim_name_lower = info->getName();
  1417. LLStringUtil::toLower(sim_name_lower);
  1419. if (sim_name_lower.substr(0, name_length) == mCompletingRegionName)
  1420. {
  1421. if (sim_name_lower == mCompletingRegionName)
  1422. {
  1423. match = info->getName();
  1424. }
  1426. LLSD value;
  1427. value["id"] = info->getName();
  1428. value["columns"][0]["column"] = "sim_name";
  1429. value["columns"][0]["value"] = info->getName();
  1430. list->addElement(value);
  1431. num_results++;
  1432. }
  1433. }
  1435. if (found_null_sim)
  1436. {
  1437. mCompletingRegionName = "";
  1438. }
  1440. // if match found, highlight it and go
  1441. if (!match.isUndefined())
  1442. {
  1443. list->selectByValue(match);
  1444. childSetFocus("search_results");
  1445. onCommitSearchResult();
  1446. }
  1448. // if we found nothing, say "none"
  1449. if (num_results == 0)
  1450. {
  1451. list->setCommentText(LLTrans::getString("worldmap_results_none_found"));
  1452. list->operateOnAll(LLCtrlListInterface::OP_DESELECT);
  1453. }
  1454. }
  1457. void LLFloaterWorldMap::onCommitSearchResult()
  1458. {
  1459. LLCtrlListInterface *list = childGetListInterface("search_results");
  1460. if (!list) return;
  1462. LLSD selected_value = list->getSelectedValue();
  1463. std::string sim_name = selected_value.asString();
  1464. if (sim_name.empty())
  1465. {
  1466. return;
  1467. }
  1468. LLStringUtil::toLower(sim_name);
  1470. std::map<U64, LLSimInfo*>::const_iterator it;
  1471. for (it = LLWorldMap::getInstance()->getRegionMap().begin(); it != LLWorldMap::getInstance()->getRegionMap().end(); ++it)
  1472. {
  1473. LLSimInfo* info = it->second;
  1475. if (info->isName(sim_name))
  1476. {
  1477. LLVector3d pos_global = info->getGlobalOrigin();
  1479. const F64 SIM_COORD_DEFAULT = 128.0;
  1480. LLVector3 pos_local(SIM_COORD_DEFAULT, SIM_COORD_DEFAULT, 0.0f);
  1482. // Did this value come from a trackURL() request?
  1483. if (!mCompletingRegionPos.isExactlyZero())
  1484. {
  1485. pos_local = mCompletingRegionPos;
  1486. mCompletingRegionPos.clear();
  1487. }
  1488. pos_global.mdV[VX] += (F64)pos_local.mV[VX];
  1489. pos_global.mdV[VY] += (F64)pos_local.mV[VY];
  1490. pos_global.mdV[VZ] = (F64)pos_local.mV[VZ];
  1492. childSetValue("location", sim_name);
  1493. trackLocation(pos_global);
  1494. setDefaultBtn("Teleport");
  1495. break;
  1496. }
  1497. }
  1499. onShowTargetBtn();
  1500. }