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

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

游戏引擎

开发平台：

C++ Builder

llcallingcard.cpp：源码内容
  1. /** 
  2.  * @file llcallingcard.cpp
  3.  * @brief Implementation of the LLPreviewCallingCard class
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #if LL_WINDOWS
  36. #pragma warning( disable : 4800 ) // performance warning in <functional>
  37. #endif
  39. #include "llcallingcard.h"
  41. #include <vector>
  42. #include <algorithm>
  43. //#include <iterator>
  45. #include "indra_constants.h"
  46. #include "llcachename.h"
  47. #include "llstl.h"
  48. #include "lltimer.h"
  49. #include "lluuid.h"
  50. #include "message.h"
  52. #include "llagent.h"
  53. #include "llbutton.h"
  54. #include "llinventoryobserver.h"
  55. #include "llinventorymodel.h"
  56. #include "llnotifications.h"
  57. #include "llnotificationsutil.h"
  58. #include "llresmgr.h"
  59. #include "llslurl.h"
  60. #include "llimview.h"
  61. #include "llviewercontrol.h"
  62. #include "llviewernetwork.h"
  63. #include "llviewerobjectlist.h"
  64. #include "llviewerwindow.h"
  65. #include "llvoavatar.h"
  66. #include "llavataractions.h"
  68. ///----------------------------------------------------------------------------
  69. /// Local function declarations, constants, enums, and typedefs
  70. ///----------------------------------------------------------------------------
  72. class LLTrackingData
  73. {
  74. public:
  75. LLTrackingData(const LLUUID& avatar_id, const std::string& name);
  76. bool haveTrackingInfo();
  77. void setTrackedCoarseLocation(const LLVector3d& global_pos);
  78. void agentFound(const LLUUID& prey,
  79. const LLVector3d& estimated_global_pos);
  81. public:
  82. LLUUID mAvatarID;
  83. std::string mName;
  84. LLVector3d mGlobalPositionEstimate;
  85. bool mHaveInfo;
  86. bool mHaveCoarseInfo;
  87. LLTimer mCoarseLocationTimer;
  88. LLTimer mUpdateTimer;
  89. LLTimer mAgentGone;
  90. };
  92. const F32 COARSE_FREQUENCY = 2.2f;
  93. const F32 FIND_FREQUENCY = 29.7f; // This results in a database query, so cut these back
  94. const F32 OFFLINE_SECONDS = FIND_FREQUENCY + 8.0f;
  96. // static
  97. LLAvatarTracker LLAvatarTracker::sInstance;
  102. ///----------------------------------------------------------------------------
  103. /// Class LLAvatarTracker
  104. ///----------------------------------------------------------------------------
  106. LLAvatarTracker::LLAvatarTracker() :
  107. mTrackingData(NULL),
  108. mTrackedAgentValid(false),
  109. //mInventory(NULL),
  110. //mInventoryObserver(NULL),
  111. mModifyMask(0x0)
  112. {
  113. }
  115. LLAvatarTracker::~LLAvatarTracker()
  116. {
  117. deleteTrackingData();
  118. std::for_each(mObservers.begin(), mObservers.end(), DeletePointer());
  119. std::for_each(mBuddyInfo.begin(), mBuddyInfo.end(), DeletePairedPointer());
  120. }
  122. void LLAvatarTracker::track(const LLUUID& avatar_id, const std::string& name)
  123. {
  124. deleteTrackingData();
  125. mTrackedAgentValid = false;
  126. mTrackingData = new LLTrackingData(avatar_id, name);
  127. findAgent();
  129. // We track here because findAgent() is called on a timer (for now).
  130. if(avatar_id.notNull())
  131. {
  132. LLMessageSystem* msg = gMessageSystem;
  133. msg->newMessageFast(_PREHASH_TrackAgent);
  134. msg->nextBlockFast(_PREHASH_AgentData);
  135. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  136. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  137. msg->nextBlockFast(_PREHASH_TargetData);
  138. msg->addUUIDFast(_PREHASH_PreyID, avatar_id);
  139. gAgent.sendReliableMessage();
  140. }
  141. }
  143. void LLAvatarTracker::untrack(const LLUUID& avatar_id)
  144. {
  145. if (mTrackingData && mTrackingData->mAvatarID == avatar_id)
  146. {
  147. deleteTrackingData();
  148. mTrackedAgentValid = false;
  149. LLMessageSystem* msg = gMessageSystem;
  150. msg->newMessageFast(_PREHASH_TrackAgent);
  151. msg->nextBlockFast(_PREHASH_AgentData);
  152. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  153. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  154. msg->nextBlockFast(_PREHASH_TargetData);
  155. msg->addUUIDFast(_PREHASH_PreyID, LLUUID::null);
  156. gAgent.sendReliableMessage();
  157. }
  158. }
  160. void LLAvatarTracker::setTrackedCoarseLocation(const LLVector3d& global_pos)
  161. {
  162. if(mTrackingData)
  163. {
  164. mTrackingData->setTrackedCoarseLocation(global_pos);
  165. }
  166. }
  168. bool LLAvatarTracker::haveTrackingInfo()
  169. {
  170. if(mTrackingData)
  171. {
  172. return mTrackingData->haveTrackingInfo();
  173. }
  174. return false;
  175. }
  177. LLVector3d LLAvatarTracker::getGlobalPos()
  178. {
  179. if(!mTrackedAgentValid || !mTrackingData) return LLVector3d();
  180. LLVector3d global_pos;
  182. LLViewerObject* object = gObjectList.findObject(mTrackingData->mAvatarID);
  183. if(object && !object->isDead())
  184. {
  185. global_pos = object->getPositionGlobal();
  186. // HACK - for making the tracker point above the avatar's head
  187. // rather than its groin
  188. global_pos.mdV[VZ] += 0.7f * ((LLVOAvatar *)object)->mBodySize.mV[VZ];
  190. mTrackingData->mGlobalPositionEstimate = global_pos;
  191. }
  192. else
  193. {
  194. global_pos = mTrackingData->mGlobalPositionEstimate;
  195. }
  197. return global_pos;
  198. }
  200. void LLAvatarTracker::getDegreesAndDist(F32& rot,
  201. F64& horiz_dist,
  202. F64& vert_dist)
  203. {
  204. if(!mTrackingData) return;
  206. LLVector3d global_pos;
  208. LLViewerObject* object = gObjectList.findObject(mTrackingData->mAvatarID);
  209. if(object && !object->isDead())
  210. {
  211. global_pos = object->getPositionGlobal();
  212. mTrackingData->mGlobalPositionEstimate = global_pos;
  213. }
  214. else
  215. {
  216. global_pos = mTrackingData->mGlobalPositionEstimate;
  217. }
  218. LLVector3d to_vec = global_pos - gAgent.getPositionGlobal();
  219. horiz_dist = sqrt(to_vec.mdV[VX] * to_vec.mdV[VX] + to_vec.mdV[VY] * to_vec.mdV[VY]);
  220. vert_dist = to_vec.mdV[VZ];
  221. rot = F32(RAD_TO_DEG * atan2(to_vec.mdV[VY], to_vec.mdV[VX]));
  222. }
  224. const std::string& LLAvatarTracker::getName()
  225. {
  226. if(mTrackingData)
  227. {
  228. return mTrackingData->mName;
  229. }
  230. else
  231. {
  232. return LLStringUtil::null;
  233. }
  234. }
  236. const LLUUID& LLAvatarTracker::getAvatarID()
  237. {
  238. if(mTrackingData)
  239. {
  240. return mTrackingData->mAvatarID;
  241. }
  242. else
  243. {
  244. return LLUUID::null;
  245. }
  246. }
  248. S32 LLAvatarTracker::addBuddyList(const LLAvatarTracker::buddy_map_t& buds)
  249. {
  250. using namespace std;
  252. U32 new_buddy_count = 0;
  253. std::string first,last;
  254. LLUUID agent_id;
  255. for(buddy_map_t::const_iterator itr = buds.begin(); itr != buds.end(); ++itr)
  256. {
  257. agent_id = (*itr).first;
  258. buddy_map_t::const_iterator existing_buddy = mBuddyInfo.find(agent_id);
  259. if(existing_buddy == mBuddyInfo.end())
  260. {
  261. ++new_buddy_count;
  262. mBuddyInfo[agent_id] = (*itr).second;
  263. gCacheName->getName(agent_id, first, last);
  264. addChangedMask(LLFriendObserver::ADD, agent_id);
  265. lldebugs << "Added buddy " << agent_id
  266. << ", " << (mBuddyInfo[agent_id]->isOnline() ? "Online" : "Offline")
  267. << ", TO: " << mBuddyInfo[agent_id]->getRightsGrantedTo()
  268. << ", FROM: " << mBuddyInfo[agent_id]->getRightsGrantedFrom()
  269. << llendl;
  270. }
  271. else
  272. {
  273. LLRelationship* e_r = (*existing_buddy).second;
  274. LLRelationship* n_r = (*itr).second;
  275. llwarns << "!! Add buddy for existing buddy: " << agent_id
  276. << " [" << (e_r->isOnline() ? "Online" : "Offline") << "->" << (n_r->isOnline() ? "Online" : "Offline")
  277. << ", " <<  e_r->getRightsGrantedTo() << "->" << n_r->getRightsGrantedTo()
  278. << ", " <<  e_r->getRightsGrantedTo() << "->" << n_r->getRightsGrantedTo()
  279. << "]" << llendl;
  280. }
  281. }
  282. notifyObservers();
  284. return new_buddy_count;
  285. }
  288. void LLAvatarTracker::copyBuddyList(buddy_map_t& buddies) const
  289. {
  290. buddy_map_t::const_iterator it = mBuddyInfo.begin();
  291. buddy_map_t::const_iterator end = mBuddyInfo.end();
  292. for(; it != end; ++it)
  293. {
  294. buddies[(*it).first] = (*it).second;
  295. }
  296. }
  298. void LLAvatarTracker::terminateBuddy(const LLUUID& id)
  299. {
  300. lldebugs << "LLAvatarTracker::terminateBuddy()" << llendl;
  301. LLRelationship* buddy = get_ptr_in_map(mBuddyInfo, id);
  302. if(!buddy) return;
  303. mBuddyInfo.erase(id);
  304. LLMessageSystem* msg = gMessageSystem;
  305. msg->newMessage("TerminateFriendship");
  306. msg->nextBlock("AgentData");
  307. msg->addUUID("AgentID", gAgent.getID());
  308. msg->addUUID("SessionID", gAgent.getSessionID());
  309. msg->nextBlock("ExBlock");
  310. msg->addUUID("OtherID", id);
  311. gAgent.sendReliableMessage();
  312.  
  313. addChangedMask(LLFriendObserver::REMOVE, id);
  314. delete buddy;
  315. }
  317. // get all buddy info
  318. const LLRelationship* LLAvatarTracker::getBuddyInfo(const LLUUID& id) const
  319. {
  320. if(id.isNull()) return NULL;
  321. return get_ptr_in_map(mBuddyInfo, id);
  322. }
  324. bool LLAvatarTracker::isBuddy(const LLUUID& id) const
  325. {
  326. LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
  327. return (info != NULL);
  328. }
  330. // online status
  331. void LLAvatarTracker::setBuddyOnline(const LLUUID& id, bool is_online)
  332. {
  333. LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
  334. if(info)
  335. {
  336. info->online(is_online);
  337. addChangedMask(LLFriendObserver::ONLINE, id);
  338. lldebugs << "Set buddy " << id << (is_online ? " Online" : " Offline") << llendl;
  339. }
  340. else
  341. {
  342. llwarns << "!! No buddy info found for " << id 
  343. << ", setting to " << (is_online ? "Online" : "Offline") << llendl;
  344. }
  345. }
  347. bool LLAvatarTracker::isBuddyOnline(const LLUUID& id) const
  348. {
  349. LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
  350. if(info)
  351. {
  352. return info->isOnline();
  353. }
  354. return false;
  355. }
  357. // empowered status
  358. void LLAvatarTracker::setBuddyEmpowered(const LLUUID& id, bool is_empowered)
  359. {
  360. LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
  361. if(info)
  362. {
  363. info->grantRights(LLRelationship::GRANT_MODIFY_OBJECTS, 0);
  364. mModifyMask |= LLFriendObserver::POWERS;
  365. }
  366. }
  368. bool LLAvatarTracker::isBuddyEmpowered(const LLUUID& id) const
  369. {
  370. LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
  371. if(info)
  372. {
  373. return info->isRightGrantedTo(LLRelationship::GRANT_MODIFY_OBJECTS);
  374. }
  375. return false;
  376. }
  378. void LLAvatarTracker::empower(const LLUUID& id, bool grant)
  379. {
  380. // wrapper for ease of use in some situations.
  381. buddy_map_t list;
  382. /*
  383. list.insert(id);
  384. empowerList(list, grant);
  385. */
  386. }
  388. void LLAvatarTracker::empowerList(const buddy_map_t& list, bool grant)
  389. {
  390. llwarns << "LLAvatarTracker::empowerList() not implemented." << llendl;
  391. /*
  392. LLMessageSystem* msg = gMessageSystem;
  393. const char* message_name;
  394. const char* block_name;
  395. const char* field_name;
  396. if(grant)
  397. {
  398. message_name = _PREHASH_GrantModification;
  399. block_name = _PREHASH_EmpoweredBlock;
  400. field_name = _PREHASH_EmpoweredID;
  401. }
  402. else
  403. {
  404. message_name = _PREHASH_RevokeModification;
  405. block_name = _PREHASH_RevokedBlock;
  406. field_name = _PREHASH_RevokedID;
  407. }
  409. std::string name;
  410. gAgent.buildFullnameAndTitle(name);
  412. bool start_new_message = true;
  413. buddy_list_t::const_iterator it = list.begin();
  414. buddy_list_t::const_iterator end = list.end();
  415. for(; it != end; ++it)
  416. {
  417. if(NULL == get_ptr_in_map(mBuddyInfo, (*it))) continue;
  418. setBuddyEmpowered((*it), grant);
  419. if(start_new_message)
  420. {
  421. start_new_message = false;
  422. msg->newMessageFast(message_name);
  423. msg->nextBlockFast(_PREHASH_AgentData);
  424. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  425. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  426. msg->addStringFast(_PREHASH_GranterName, name);
  427. }
  428. msg->nextBlockFast(block_name);
  429. msg->addUUIDFast(field_name, (*it));
  430. if(msg->isSendFullFast(block_name))
  431. {
  432. start_new_message = true;
  433. gAgent.sendReliableMessage();
  434. }
  435. }
  436. if(!start_new_message)
  437. {
  438. gAgent.sendReliableMessage();
  439. }
  440. */
  441. }
  443. void LLAvatarTracker::deleteTrackingData()
  444. {
  445. //make sure mTrackingData never points to freed memory
  446. LLTrackingData* tmp = mTrackingData;
  447. mTrackingData = NULL;
  448. delete tmp;
  449. }
  451. void LLAvatarTracker::findAgent()
  452. {
  453. if (!mTrackingData) return;
  454. if (mTrackingData->mAvatarID.isNull()) return;
  455. LLMessageSystem* msg = gMessageSystem;
  456. msg->newMessageFast(_PREHASH_FindAgent); // Request
  457. msg->nextBlockFast(_PREHASH_AgentBlock);
  458. msg->addUUIDFast(_PREHASH_Hunter, gAgentID);
  459. msg->addUUIDFast(_PREHASH_Prey, mTrackingData->mAvatarID);
  460. msg->addU32Fast(_PREHASH_SpaceIP, 0); // will get filled in by simulator
  461. msg->nextBlockFast(_PREHASH_LocationBlock);
  462. const F64 NO_LOCATION = 0.0;
  463. msg->addF64Fast(_PREHASH_GlobalX, NO_LOCATION);
  464. msg->addF64Fast(_PREHASH_GlobalY, NO_LOCATION);
  465. gAgent.sendReliableMessage();
  466. }
  468. void LLAvatarTracker::addObserver(LLFriendObserver* observer)
  469. {
  470. if(observer)
  471. {
  472. mObservers.push_back(observer);
  473. }
  474. }
  476. void LLAvatarTracker::removeObserver(LLFriendObserver* observer)
  477. {
  478. mObservers.erase(
  479. std::remove(mObservers.begin(), mObservers.end(), observer),
  480. mObservers.end());
  481. }
  483. void LLAvatarTracker::notifyObservers()
  484. {
  485. observer_list_t observers(mObservers);
  486. observer_list_t::iterator it = observers.begin();
  487. observer_list_t::iterator end = observers.end();
  488. for(; it != end; ++it)
  489. {
  490. (*it)->changed(mModifyMask);
  491. }
  493. for (changed_buddy_t::iterator it = mChangedBuddyIDs.begin(); it != mChangedBuddyIDs.end(); it++)
  494. {
  495. notifyParticularFriendObservers(*it);
  496. }
  498. mModifyMask = LLFriendObserver::NONE;
  499. mChangedBuddyIDs.clear();
  500. }
  502. void LLAvatarTracker::addParticularFriendObserver(const LLUUID& buddy_id, LLFriendObserver* observer)
  503. {
  504. if (buddy_id.notNull() && observer)
  505. mParticularFriendObserverMap[buddy_id].insert(observer);
  506. }
  508. void LLAvatarTracker::removeParticularFriendObserver(const LLUUID& buddy_id, LLFriendObserver* observer)
  509. {
  510. if (buddy_id.isNull() || !observer)
  511. return;
  513.     observer_map_t::iterator obs_it = mParticularFriendObserverMap.find(buddy_id);
  514.     if(obs_it == mParticularFriendObserverMap.end())
  515.         return;
  517.     obs_it->second.erase(observer);
  519.     // purge empty sets from the map
  520.     if (obs_it->second.size() == 0)
  521.      mParticularFriendObserverMap.erase(obs_it);
  522. }
  524. void LLAvatarTracker::notifyParticularFriendObservers(const LLUUID& buddy_id)
  525. {
  526.     observer_map_t::iterator obs_it = mParticularFriendObserverMap.find(buddy_id);
  527.     if(obs_it == mParticularFriendObserverMap.end())
  528.         return;
  530.     // Notify observers interested in buddy_id.
  531.     observer_set_t& obs = obs_it->second;
  532.     for (observer_set_t::iterator ob_it = obs.begin(); ob_it != obs.end(); ob_it++)
  533.     {
  534.         (*ob_it)->changed(mModifyMask);
  535.     }
  536. }
  538. // store flag for change
  539. // and id of object change applies to
  540. void LLAvatarTracker::addChangedMask(U32 mask, const LLUUID& referent)
  541. { 
  542. mModifyMask |= mask; 
  543. if (referent.notNull())
  544. {
  545. mChangedBuddyIDs.insert(referent);
  546. }
  547. }
  549. void LLAvatarTracker::applyFunctor(LLRelationshipFunctor& f)
  550. {
  551. buddy_map_t::iterator it = mBuddyInfo.begin();
  552. buddy_map_t::iterator end = mBuddyInfo.end();
  553. for(; it != end; ++it)
  554. {
  555. f((*it).first, (*it).second);
  556. }
  557. }
  559. void LLAvatarTracker::registerCallbacks(LLMessageSystem* msg)
  560. {
  561. msg->setHandlerFuncFast(_PREHASH_FindAgent, processAgentFound);
  562. msg->setHandlerFuncFast(_PREHASH_OnlineNotification,
  563. processOnlineNotification);
  564. msg->setHandlerFuncFast(_PREHASH_OfflineNotification,
  565. processOfflineNotification);
  566. //msg->setHandlerFuncFast(_PREHASH_GrantedProxies,
  567. // processGrantedProxies);
  568. msg->setHandlerFunc("TerminateFriendship", processTerminateFriendship);
  569. msg->setHandlerFunc(_PREHASH_ChangeUserRights, processChangeUserRights);
  570. }
  572. // static
  573. void LLAvatarTracker::processAgentFound(LLMessageSystem* msg, void**)
  574. {
  575. LLUUID id;
  578. msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_Hunter, id);
  579. msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_Prey, id);
  580. // *FIX: should make sure prey id matches.
  581. LLVector3d estimated_global_pos;
  582. msg->getF64Fast(_PREHASH_LocationBlock, _PREHASH_GlobalX,
  583.  estimated_global_pos.mdV[VX]);
  584. msg->getF64Fast(_PREHASH_LocationBlock, _PREHASH_GlobalY,
  585.  estimated_global_pos.mdV[VY]);
  586. LLAvatarTracker::instance().agentFound(id, estimated_global_pos);
  587. }
  589. void LLAvatarTracker::agentFound(const LLUUID& prey,
  590.  const LLVector3d& estimated_global_pos)
  591. {
  592. if(!mTrackingData) return;
  593. //if we get a valid reply from the server, that means the agent
  594. //is our friend and mappable, so enable interest list based updates
  595. LLAvatarTracker::instance().setTrackedAgentValid(true);
  596. mTrackingData->agentFound(prey, estimated_global_pos);
  597. }
  599. //  static
  600. void LLAvatarTracker::processOnlineNotification(LLMessageSystem* msg, void**)
  601. {
  602. lldebugs << "LLAvatarTracker::processOnlineNotification()" << llendl;
  603. instance().processNotify(msg, true);
  604. }
  606. //  static
  607. void LLAvatarTracker::processOfflineNotification(LLMessageSystem* msg, void**)
  608. {
  609. lldebugs << "LLAvatarTracker::processOfflineNotification()" << llendl;
  610. instance().processNotify(msg, false);
  611. }
  613. void LLAvatarTracker::processChange(LLMessageSystem* msg)
  614. {
  615. S32 count = msg->getNumberOfBlocksFast(_PREHASH_Rights);
  616. LLUUID agent_id, agent_related;
  617. S32 new_rights;
  618. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
  619. for(int i = 0; i < count; ++i)
  620. {
  621. msg->getUUIDFast(_PREHASH_Rights, _PREHASH_AgentRelated, agent_related, i);
  622. msg->getS32Fast(_PREHASH_Rights,_PREHASH_RelatedRights, new_rights, i);
  623. if(agent_id == gAgent.getID())
  624. {
  625. if(mBuddyInfo.find(agent_related) != mBuddyInfo.end())
  626. {
  627. (mBuddyInfo[agent_related])->setRightsTo(new_rights);
  628. }
  629. }
  630. else
  631. {
  632. if(mBuddyInfo.find(agent_id) != mBuddyInfo.end())
  633. {
  634. if((mBuddyInfo[agent_id]->getRightsGrantedFrom() ^  new_rights) & LLRelationship::GRANT_MODIFY_OBJECTS)
  635. {
  636. std::string name;
  637. LLSD args;
  638. if(gCacheName->getFullName(agent_id, name))
  639. {
  640. args["NAME"] = name;
  641. }
  642. LLSD payload;
  643. payload["from_id"] = agent_id;
  644. if(LLRelationship::GRANT_MODIFY_OBJECTS & new_rights)
  645. {
  646. LLNotificationsUtil::add("GrantedModifyRights",args, payload);
  647. }
  648. else
  649. {
  650. LLNotificationsUtil::add("RevokedModifyRights",args, payload);
  651. }
  652. }
  653. (mBuddyInfo[agent_id])->setRightsFrom(new_rights);
  654. }
  655. }
  656. }
  658. addChangedMask(LLFriendObserver::POWERS, agent_id);
  659. notifyObservers();
  660. }
  662. void LLAvatarTracker::processChangeUserRights(LLMessageSystem* msg, void**)
  663. {
  664. lldebugs << "LLAvatarTracker::processChangeUserRights()" << llendl;
  665. instance().processChange(msg);
  666. }
  668. void LLAvatarTracker::processNotify(LLMessageSystem* msg, bool online)
  669. {
  670. S32 count = msg->getNumberOfBlocksFast(_PREHASH_AgentBlock);
  671. BOOL chat_notify = gSavedSettings.getBOOL("ChatOnlineNotification");
  673. lldebugs << "Received " << count << " online notifications **** " << llendl;
  674. if(count > 0)
  675. {
  676. LLUUID agent_id;
  677. const LLRelationship* info = NULL;
  678. LLUUID tracking_id;
  679. if(mTrackingData)
  680. {
  681. tracking_id = mTrackingData->mAvatarID;
  682. }
  683. BOOL notify = FALSE;
  684. LLSD args;
  685. LLSD payload;
  686. for(S32 i = 0; i < count; ++i)
  687. {
  688. msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_AgentID, agent_id, i);
  689. payload["FROM_ID"] = agent_id;
  690. info = getBuddyInfo(agent_id);
  691. if(info)
  692. {
  693. setBuddyOnline(agent_id,online);
  694. if(chat_notify)
  695. {
  696. std::string first, last;
  697. if(gCacheName->getName(agent_id, first, last))
  698. {
  699. notify = TRUE;
  700. args["FIRST"] = first;
  701. args["LAST"] = last;
  702. }
  703. }
  704. }
  705. else
  706. {
  707. llwarns << "Received online notification for unknown buddy: " 
  708. << agent_id << " is " << (online ? "ONLINE" : "OFFLINE") << llendl;
  709. }
  711. if(tracking_id == agent_id)
  712. {
  713. // we were tracking someone who went offline
  714. deleteTrackingData();
  715. }
  716. // *TODO: get actual inventory id
  717. gInventory.addChangedMask(LLInventoryObserver::CALLING_CARD, LLUUID::null);
  718. }
  719. if(notify)
  720. {
  721. // Popup a notify box with online status of this agent
  722. LLNotificationPtr notification;
  724. if (online)
  725. {
  726. notification =
  727. LLNotificationsUtil::add("FriendOnline",
  728.  args,
  729.  payload.with("respond_on_mousedown", TRUE),
  730.  boost::bind(&LLAvatarActions::startIM, agent_id));
  731. }
  732. else
  733. {
  734. notification =
  735. LLNotificationsUtil::add("FriendOffline", args, payload);
  736. }
  738. // If there's an open IM session with this agent, send a notification there too.
  739. LLUUID session_id = LLIMMgr::computeSessionID(IM_NOTHING_SPECIAL, agent_id);
  740. std::string notify_msg = notification->getMessage();
  741. LLIMModel::instance().proccessOnlineOfflineNotification(session_id, notify_msg);
  742. }
  744. mModifyMask |= LLFriendObserver::ONLINE;
  745. instance().notifyObservers();
  746. gInventory.notifyObservers();
  747. }
  748. }
  750. void LLAvatarTracker::formFriendship(const LLUUID& id)
  751. {
  752. if(id.notNull())
  753. {
  754. LLRelationship* buddy_info = get_ptr_in_map(instance().mBuddyInfo, id);
  755. if(!buddy_info)
  756. {
  757. LLAvatarTracker& at = LLAvatarTracker::instance();
  758. //The default for relationship establishment is to have both parties
  759. //visible online to each other.
  760. buddy_info = new LLRelationship(LLRelationship::GRANT_ONLINE_STATUS,LLRelationship::GRANT_ONLINE_STATUS, false);
  761. at.mBuddyInfo[id] = buddy_info;
  762. at.addChangedMask(LLFriendObserver::ADD, id);
  763. at.notifyObservers();
  764. }
  765. }
  766. }
  768. void LLAvatarTracker::processTerminateFriendship(LLMessageSystem* msg, void**)
  769. {
  770. LLUUID id;
  771. msg->getUUID("ExBlock", "OtherID", id);
  772. if(id.notNull())
  773. {
  774. LLAvatarTracker& at = LLAvatarTracker::instance();
  775. LLRelationship* buddy = get_ptr_in_map(at.mBuddyInfo, id);
  776. if(!buddy) return;
  777. at.mBuddyInfo.erase(id);
  778. at.addChangedMask(LLFriendObserver::REMOVE, id);
  779. delete buddy;
  780. at.notifyObservers();
  781. }
  782. }
  784. ///----------------------------------------------------------------------------
  785. /// Tracking Data
  786. ///----------------------------------------------------------------------------
  788. LLTrackingData::LLTrackingData(const LLUUID& avatar_id, const std::string& name)
  789. : mAvatarID(avatar_id),
  790. mHaveInfo(false),
  791. mHaveCoarseInfo(false)
  792. {
  793. mCoarseLocationTimer.setTimerExpirySec(COARSE_FREQUENCY);
  794. mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
  795. mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
  796. if(!name.empty())
  797. {
  798. mName = name;
  799. }
  800. }
  802. void LLTrackingData::agentFound(const LLUUID& prey,
  803. const LLVector3d& estimated_global_pos)
  804. {
  805. if(prey != mAvatarID)
  806. {
  807. llwarns << "LLTrackingData::agentFound() - found " << prey
  808. << " but looking for " << mAvatarID << llendl;
  809. }
  810. mHaveInfo = true;
  811. mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
  812. mGlobalPositionEstimate = estimated_global_pos;
  813. }
  815. bool LLTrackingData::haveTrackingInfo()
  816. {
  817. LLViewerObject* object = gObjectList.findObject(mAvatarID);
  818. if(object && !object->isDead())
  819. {
  820. mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY);
  821. mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
  822. mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
  823. mHaveInfo = true;
  824. return true;
  825. }
  826. if(mHaveCoarseInfo &&
  827.    !mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY))
  828. {
  829. // if we reach here, then we have a 'recent' coarse update
  830. mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
  831. mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
  832. return true;
  833. }
  834. if(mUpdateTimer.checkExpirationAndReset(FIND_FREQUENCY))
  835. {
  836. LLAvatarTracker::instance().findAgent();
  837. mHaveCoarseInfo = false;
  838. }
  839. if(mAgentGone.checkExpirationAndReset(OFFLINE_SECONDS))
  840. {
  841. mHaveInfo = false;
  842. mHaveCoarseInfo = false;
  843. }
  844. return mHaveInfo;
  845. }
  847. void LLTrackingData::setTrackedCoarseLocation(const LLVector3d& global_pos)
  848. {
  849. mCoarseLocationTimer.setTimerExpirySec(COARSE_FREQUENCY);
  850. mGlobalPositionEstimate = global_pos;
  851. mHaveInfo = true;
  852. mHaveCoarseInfo = true;
  853. }
  855. ///----------------------------------------------------------------------------
  856. // various buddy functors
  857. ///----------------------------------------------------------------------------
  859. bool LLCollectProxyBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
  860. {
  861. if(buddy->isRightGrantedFrom(LLRelationship::GRANT_MODIFY_OBJECTS))
  862. {
  863. mProxy.insert(buddy_id);
  864. }
  865. return true;
  866. }
  868. bool LLCollectMappableBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
  869. {
  870. gCacheName->getName(buddy_id, mFirst, mLast);
  871. std::ostringstream fullname;
  872. fullname << mFirst << " " << mLast;
  873. buddy_map_t::value_type value(fullname.str(), buddy_id);
  874. if(buddy->isOnline() && buddy->isRightGrantedFrom(LLRelationship::GRANT_MAP_LOCATION))
  875. {
  876. mMappable.insert(value);
  877. }
  878. return true;
  879. }
  881. bool LLCollectOnlineBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
  882. {
  883. gCacheName->getName(buddy_id, mFirst, mLast);
  884. std::ostringstream fullname;
  885. fullname << mFirst << " " << mLast;
  886. buddy_map_t::value_type value(fullname.str(), buddy_id);
  887. if(buddy->isOnline())
  888. {
  889. mOnline.insert(value);
  890. }
  891. return true;
  892. }
  894. bool LLCollectAllBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
  895. {
  896. gCacheName->getName(buddy_id, mFirst, mLast);
  897. std::ostringstream fullname;
  898. fullname << mFirst << " " << mLast;
  899. buddy_map_t::value_type value(fullname.str(), buddy_id);
  900. if(buddy->isOnline())
  901. {
  902. mOnline.insert(value);
  903. }
  904. else
  905. {
  906. mOffline.insert(value);
  907. }
  908. return true;
  909. }