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

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

游戏引擎

开发平台：

C++ Builder

lltoolpie.cpp：源码内容
  1. /** 
  2.  * @file lltoolpie.cpp
  3.  * @brief LLToolPie class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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. #include "lltoolpie.h"
  37. #include "indra_constants.h"
  38. #include "llclickaction.h"
  39. #include "llparcel.h"
  41. #include "llagent.h"
  42. #include "llviewercontrol.h"
  43. #include "llfocusmgr.h"
  44. //#include "llfirstuse.h"
  45. #include "llfloaterland.h"
  46. #include "llfloaterreg.h"
  47. #include "llfloaterscriptdebug.h"
  48. #include "lltooltip.h"
  49. #include "llhudeffecttrail.h"
  50. #include "llhudmanager.h"
  51. #include "llkeyboard.h"
  52. #include "llmediaentry.h"
  53. #include "llmenugl.h"
  54. #include "llmutelist.h"
  55. #include "llselectmgr.h"
  56. #include "lltoolfocus.h"
  57. #include "lltoolgrab.h"
  58. #include "lltoolmgr.h"
  59. #include "lltoolselect.h"
  60. #include "lltrans.h"
  61. #include "llviewercamera.h"
  62. #include "llviewerparcelmedia.h"
  63. #include "llviewermenu.h"
  64. #include "llviewerobjectlist.h"
  65. #include "llviewerobject.h"
  66. #include "llviewerparcelmgr.h"
  67. #include "llviewerwindow.h"
  68. #include "llviewermedia.h"
  69. #include "llvoavatarself.h"
  70. #include "llviewermediafocus.h"
  71. #include "llworld.h"
  72. #include "llui.h"
  73. #include "llweb.h"
  74. #include "pipeline.h" // setHighlightObject
  76. extern BOOL gDebugClicks;
  78. static void handle_click_action_play();
  79. static void handle_click_action_open_media(LLPointer<LLViewerObject> objectp);
  80. static ECursorType cursor_from_parcel_media(U8 click_action);
  83. LLToolPie::LLToolPie()
  84. : LLTool(std::string("Pie")),
  85. mGrabMouseButtonDown( FALSE ),
  86. mMouseOutsideSlop( FALSE ),
  87. mClickAction(0)
  88. { }
  91. BOOL LLToolPie::handleAnyMouseClick(S32 x, S32 y, MASK mask, EClickType clicktype, BOOL down)
  92. {
  93. BOOL result = LLMouseHandler::handleAnyMouseClick(x, y, mask, clicktype, down);
  95. // This override DISABLES the keyboard focus reset that LLTool::handleAnyMouseClick adds.
  96. // LLToolPie will do the right thing in its pick callback.
  98. return result;
  99. }
  101. BOOL LLToolPie::handleMouseDown(S32 x, S32 y, MASK mask)
  102. {
  103. //left mouse down always picks transparent
  104. mPick = gViewerWindow->pickImmediate(x, y, TRUE);
  105. mPick.mKeyMask = mask;
  106. mGrabMouseButtonDown = TRUE;
  108. pickLeftMouseDownCallback();
  110. return TRUE;
  111. }
  113. // Spawn context menus on right mouse down so you can drag over and select
  114. // an item.
  115. BOOL LLToolPie::handleRightMouseDown(S32 x, S32 y, MASK mask)
  116. {
  117. // don't pick transparent so users can't "pay" transparent objects
  118. mPick = gViewerWindow->pickImmediate(x, y, FALSE);
  119. mPick.mKeyMask = mask;
  121. // claim not handled so UI focus stays same
  123. pickRightMouseDownCallback();
  125. return FALSE;
  126. }
  128. BOOL LLToolPie::handleRightMouseUp(S32 x, S32 y, MASK mask)
  129. {
  130. LLToolMgr::getInstance()->clearTransientTool();
  131. return LLTool::handleRightMouseUp(x, y, mask);
  132. }
  134. BOOL LLToolPie::handleScrollWheel(S32 x, S32 y, S32 clicks)
  135. {
  136. return LLViewerMediaFocus::getInstance()->handleScrollWheel(x, y, clicks);
  137. }
  139. // True if you selected an object.
  140. BOOL LLToolPie::pickLeftMouseDownCallback()
  141. {
  142. S32 x = mPick.mMousePt.mX;
  143. S32 y = mPick.mMousePt.mY;
  144. MASK mask = mPick.mKeyMask;
  145. if (mPick.mPickType == LLPickInfo::PICK_PARCEL_WALL)
  146. {
  147. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getCollisionParcel();
  148. if (parcel)
  149. {
  150. LLViewerParcelMgr::getInstance()->selectCollisionParcel();
  151. if (parcel->getParcelFlag(PF_USE_PASS_LIST) 
  152. && !LLViewerParcelMgr::getInstance()->isCollisionBanned())
  153. {
  154. // if selling passes, just buy one
  155. void* deselect_when_done = (void*)TRUE;
  156. LLPanelLandGeneral::onClickBuyPass(deselect_when_done);
  157. }
  158. else
  159. {
  160. // not selling passes, get info
  161. LLFloaterReg::showInstance("about_land");
  162. }
  163. }
  165. gFocusMgr.setKeyboardFocus(NULL);
  166. return LLTool::handleMouseDown(x, y, mask);
  167. }
  169. // didn't click in any UI object, so must have clicked in the world
  170. LLViewerObject *object = mPick.getObject();
  171. LLViewerObject *parent = NULL;
  173. if (mPick.mPickType != LLPickInfo::PICK_LAND)
  174. {
  175. LLViewerParcelMgr::getInstance()->deselectLand();
  176. }
  178. if (object)
  179. {
  180. parent = object->getRootEdit();
  181. }
  184. BOOL touchable = (object && object->flagHandleTouch()) 
  185.  || (parent && parent->flagHandleTouch());
  188. // If it's a left-click, and we have a special action, do it.
  189. if (useClickAction(mask, object, parent))
  190. {
  191. mClickAction = 0;
  192. if (object && object->getClickAction()) 
  193. {
  194. mClickAction = object->getClickAction();
  195. }
  196. else if (parent && parent->getClickAction()) 
  197. {
  198. mClickAction = parent->getClickAction();
  199. }
  201. switch(mClickAction)
  202. {
  203. case CLICK_ACTION_TOUCH:
  204. // touch behavior down below...
  205. break;
  206. case CLICK_ACTION_SIT:
  208. if ((gAgent.getAvatarObject() != NULL) && (!gAgent.getAvatarObject()->isSitting())) // agent not already sitting
  209. {
  210. handle_object_sit_or_stand();
  211. // put focus in world when sitting on an object
  212. gFocusMgr.setKeyboardFocus(NULL);
  213. return TRUE;
  214. } // else nothing (fall through to touch)
  216. case CLICK_ACTION_PAY:
  217. if ((object && object->flagTakesMoney())
  218. || (parent && parent->flagTakesMoney()))
  219. {
  220. // pay event goes to object actually clicked on
  221. mClickActionObject = object;
  222. mLeftClickSelection = LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE);
  223. if (LLSelectMgr::getInstance()->selectGetAllValid())
  224. {
  225. // call this right away, since we have all the info we need to continue the action
  226. selectionPropertiesReceived();
  227. }
  228. return TRUE;
  229. }
  230. break;
  231. case CLICK_ACTION_BUY:
  232. mClickActionObject = parent;
  233. mLeftClickSelection = LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE, TRUE);
  234. if (LLSelectMgr::getInstance()->selectGetAllValid())
  235. {
  236. // call this right away, since we have all the info we need to continue the action
  237. selectionPropertiesReceived();
  238. }
  239. return TRUE;
  240. case CLICK_ACTION_OPEN:
  241. if (parent && parent->allowOpen())
  242. {
  243. mClickActionObject = parent;
  244. mLeftClickSelection = LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE, TRUE);
  245. if (LLSelectMgr::getInstance()->selectGetAllValid())
  246. {
  247. // call this right away, since we have all the info we need to continue the action
  248. selectionPropertiesReceived();
  249. }
  250. }
  251. return TRUE;
  252. case CLICK_ACTION_PLAY:
  253. handle_click_action_play();
  254. return TRUE;
  255. case CLICK_ACTION_OPEN_MEDIA:
  256. // mClickActionObject = object;
  257. handle_click_action_open_media(object);
  258. return TRUE;
  259. case CLICK_ACTION_ZOOM:
  260. {
  261. const F32 PADDING_FACTOR = 2.f;
  262. LLViewerObject* object = gObjectList.findObject(mPick.mObjectID);
  264. if (object)
  265. {
  266. gAgent.setFocusOnAvatar(FALSE, ANIMATE);
  268. LLBBox bbox = object->getBoundingBoxAgent() ;
  269. F32 angle_of_view = llmax(0.1f, LLViewerCamera::getInstance()->getAspect() > 1.f ? LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect() : LLViewerCamera::getInstance()->getView());
  270. F32 distance = bbox.getExtentLocal().magVec() * PADDING_FACTOR / atan(angle_of_view);
  272. LLVector3 obj_to_cam = LLViewerCamera::getInstance()->getOrigin() - bbox.getCenterAgent();
  273. obj_to_cam.normVec();
  275. LLVector3d object_center_global = gAgent.getPosGlobalFromAgent(bbox.getCenterAgent());
  276. gAgent.setCameraPosAndFocusGlobal(object_center_global + LLVector3d(obj_to_cam * distance), 
  277.   object_center_global, 
  278.   mPick.mObjectID );
  279. }
  280. }
  281. return TRUE;
  282. default:
  283. // nothing
  284. break;
  285. }
  286. }
  288. if (handleMediaClick(mPick))
  289. {
  290. return TRUE;
  291. }
  293. // put focus back "in world"
  294. gFocusMgr.setKeyboardFocus(NULL);
  296. // Switch to grab tool if physical or triggerable
  297. if (object && 
  298. !object->isAvatar() && 
  299. ((object->usePhysics() || (parent && !parent->isAvatar() && parent->usePhysics())) || touchable) 
  300. )
  301. {
  302. gGrabTransientTool = this;
  303. LLToolMgr::getInstance()->getCurrentToolset()->selectTool( LLToolGrab::getInstance() );
  304. return LLToolGrab::getInstance()->handleObjectHit( mPick );
  305. }
  307. LLHUDIcon* last_hit_hud_icon = mPick.mHUDIcon;
  308. if (!object && last_hit_hud_icon && last_hit_hud_icon->getSourceObject())
  309. {
  310. LLFloaterScriptDebug::show(last_hit_hud_icon->getSourceObject()->getID());
  311. }
  313. // If left-click never selects or spawns a menu
  314. // Eat the event.
  315. if (!gSavedSettings.getBOOL("LeftClickShowMenu"))
  316. {
  317. // mouse already released
  318. if (!mGrabMouseButtonDown)
  319. {
  320. return TRUE;
  321. }
  323. while( object && object->isAttachment() && !object->flagHandleTouch())
  324. {
  325. // don't pick avatar through hud attachment
  326. if (object->isHUDAttachment())
  327. {
  328. break;
  329. }
  330. object = (LLViewerObject*)object->getParent();
  331. }
  332. if (object && object == gAgent.getAvatarObject())
  333. {
  334. // we left clicked on avatar, switch to focus mode
  335. LLToolMgr::getInstance()->setTransientTool(LLToolCamera::getInstance());
  336. gViewerWindow->hideCursor();
  337. LLToolCamera::getInstance()->setMouseCapture(TRUE);
  338. LLToolCamera::getInstance()->pickCallback(mPick);
  339. gAgent.setFocusOnAvatar(TRUE, TRUE);
  341. return TRUE;
  342. }
  343. //////////
  344. // // Could be first left-click on nothing
  345. // LLFirstUse::useLeftClickNoHit();
  346. /////////
  348. // Eat the event
  349. return LLTool::handleMouseDown(x, y, mask);
  350. }
  352. if (gAgent.leftButtonGrabbed())
  353. {
  354. // if the left button is grabbed, don't put up the pie menu
  355. return LLTool::handleMouseDown(x, y, mask);
  356. }
  358. // Can't ignore children here.
  359. LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE);
  361. // Spawn pie menu
  362. LLTool::handleRightMouseDown(x, y, mask);
  363. return TRUE;
  364. }
  366. BOOL LLToolPie::useClickAction(MASK mask, 
  367.    LLViewerObject* object, 
  368.    LLViewerObject* parent)
  369. {
  370. return mask == MASK_NONE
  371. && object
  372. && !object->isAttachment() 
  373. && LLPrimitive::isPrimitive(object->getPCode())
  374. && (object->getClickAction() 
  375. || parent->getClickAction());
  377. }
  379. U8 final_click_action(LLViewerObject* obj)
  380. {
  381. if (!obj) return CLICK_ACTION_NONE;
  382. if (obj->isAttachment()) return CLICK_ACTION_NONE;
  384. U8 click_action = CLICK_ACTION_TOUCH;
  385. LLViewerObject* parent = obj->getRootEdit();
  386. if (obj->getClickAction()
  387.     || (parent && parent->getClickAction()))
  388. {
  389. if (obj->getClickAction())
  390. {
  391. click_action = obj->getClickAction();
  392. }
  393. else if (parent && parent->getClickAction())
  394. {
  395. click_action = parent->getClickAction();
  396. }
  397. }
  398. return click_action;
  399. }
  401. ECursorType cursor_from_object(LLViewerObject* object)
  402. {
  403. LLViewerObject* parent = NULL;
  404. if (object)
  405. {
  406. parent = object->getRootEdit();
  407. }
  408. U8 click_action = final_click_action(object);
  409. ECursorType cursor = UI_CURSOR_ARROW;
  410. switch(click_action)
  411. {
  412. case CLICK_ACTION_SIT:
  413. if ((gAgent.getAvatarObject() != NULL) && (!gAgent.getAvatarObject()->isSitting())) // not already sitting?
  414. {
  415. cursor = UI_CURSOR_HAND;
  416. }
  417. break;
  418. case CLICK_ACTION_BUY:
  419. cursor = UI_CURSOR_HAND;
  420. break;
  421. case CLICK_ACTION_OPEN:
  422. // Open always opens the parent.
  423. if (parent && parent->allowOpen())
  424. {
  425. cursor = UI_CURSOR_HAND;
  426. }
  427. break;
  428. case CLICK_ACTION_PAY:
  429. if ((object && object->flagTakesMoney())
  430. || (parent && parent->flagTakesMoney()))
  431. {
  432. cursor = UI_CURSOR_HAND;
  433. }
  434. break;
  435. case CLICK_ACTION_ZOOM:
  436. cursor = UI_CURSOR_TOOLZOOMIN;
  437. break;
  438. case CLICK_ACTION_PLAY:
  439. case CLICK_ACTION_OPEN_MEDIA: 
  440. cursor = cursor_from_parcel_media(click_action);
  441. break;
  442. default:
  443. break;
  444. }
  445. return cursor;
  446. }
  448. void LLToolPie::resetSelection()
  449. {
  450. mLeftClickSelection = NULL;
  451. mClickActionObject = NULL;
  452. mClickAction = 0;
  453. }
  455. // When we get object properties after left-clicking on an object
  456. // with left-click = buy, if it's the same object, do the buy.
  458. // static
  459. void LLToolPie::selectionPropertiesReceived()
  460. {
  461. // Make sure all data has been received.
  462. // This function will be called repeatedly as the data comes in.
  463. if (!LLSelectMgr::getInstance()->selectGetAllValid())
  464. {
  465. return;
  466. }
  468. LLObjectSelection* selection = LLToolPie::getInstance()->getLeftClickSelection();
  469. if (selection)
  470. {
  471. LLViewerObject* selected_object = selection->getPrimaryObject();
  472. // since we don't currently have a way to lock a selection, it could have changed
  473. // after we initially clicked on the object
  474. if (selected_object == LLToolPie::getInstance()->getClickActionObject())
  475. {
  476. U8 click_action = LLToolPie::getInstance()->getClickAction();
  477. switch (click_action)
  478. {
  479. case CLICK_ACTION_BUY:
  480. handle_buy();
  481. break;
  482. case CLICK_ACTION_PAY:
  483. handle_give_money_dialog();
  484. break;
  485. case CLICK_ACTION_OPEN:
  486. LLFloaterReg::showInstance("openobject");
  487. break;
  488. default:
  489. break;
  490. }
  491. }
  492. }
  493. LLToolPie::getInstance()->resetSelection();
  494. }
  496. BOOL LLToolPie::handleHover(S32 x, S32 y, MASK mask)
  497. {
  498. mHoverPick = gViewerWindow->pickImmediate(x, y, FALSE);
  500. // Show screen-space highlight glow effect
  501. bool show_highlight = false;
  502. LLViewerObject *parent = NULL;
  503. LLViewerObject *object = mHoverPick.getObject();
  505. if (object)
  506. {
  507. parent = object->getRootEdit();
  508. }
  510. if (object && useClickAction(mask, object, parent))
  511. {
  512. show_highlight = true;
  513. ECursorType cursor = cursor_from_object(object);
  514. gViewerWindow->setCursor(cursor);
  515. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
  516. }
  517. else if (handleMediaHover(mHoverPick))
  518. {
  519. // *NOTE: If you think the hover glow conflicts with the media outline, you
  520. // could disable it here.
  521. show_highlight = true;
  522. // cursor set by media object
  523. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
  524. }
  525. else if ((object && !object->isAvatar() && object->usePhysics()) 
  526.  || (parent && !parent->isAvatar() && parent->usePhysics()))
  527. {
  528. show_highlight = true;
  529. gViewerWindow->setCursor(UI_CURSOR_TOOLGRAB);
  530. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
  531. }
  532. else if ( (object && object->flagHandleTouch()) 
  533.   || (parent && parent->flagHandleTouch()))
  534. {
  535. show_highlight = true;
  536. gViewerWindow->setCursor(UI_CURSOR_HAND);
  537. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
  538. }
  539. else
  540. {
  541. gViewerWindow->setCursor(UI_CURSOR_ARROW);
  542. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
  544. if(!object)
  545. {
  546. LLViewerMediaFocus::getInstance()->clearHover();
  547. }
  548. }
  550. static LLCachedControl<bool> enable_highlight(
  551. gSavedSettings, "RenderHoverGlowEnable", false);
  552. LLDrawable* drawable = NULL;
  553. if (enable_highlight && show_highlight && object)
  554. {
  555. drawable = object->mDrawable;
  556. }
  557. gPipeline.setHighlightObject(drawable);
  559. return TRUE;
  560. }
  562. BOOL LLToolPie::handleMouseUp(S32 x, S32 y, MASK mask)
  563. {
  564. LLViewerObject* obj = mPick.getObject();
  566. handleMediaMouseUp();
  568. U8 click_action = final_click_action(obj);
  569. if (click_action != CLICK_ACTION_NONE)
  570. {
  571. switch(click_action)
  572. {
  573. case CLICK_ACTION_BUY:
  574. case CLICK_ACTION_PAY:
  575. case CLICK_ACTION_OPEN:
  576. case CLICK_ACTION_ZOOM:
  577. case CLICK_ACTION_PLAY:
  578. case CLICK_ACTION_OPEN_MEDIA:
  579. // Because these actions open UI dialogs, we won't change
  580. // the cursor again until the next hover and GL pick over
  581. // the world.  Keep the cursor an arrow, assuming that 
  582. // after the user moves off the UI, they won't be on the
  583. // same object anymore.
  584. gViewerWindow->setCursor(UI_CURSOR_ARROW);
  585. // Make sure the hover-picked object is ignored.
  586. //gToolTipView->resetLastHoverObject();
  587. break;
  588. default:
  589. break;
  590. }
  591. }
  593. mGrabMouseButtonDown = FALSE;
  594. LLToolMgr::getInstance()->clearTransientTool();
  595. gAgent.setLookAt(LOOKAT_TARGET_CONVERSATION, obj); // maybe look at object/person clicked on
  596. return LLTool::handleMouseUp(x, y, mask);
  597. }
  600. BOOL LLToolPie::handleDoubleClick(S32 x, S32 y, MASK mask)
  601. {
  602. if (gDebugClicks)
  603. {
  604. llinfos << "LLToolPie handleDoubleClick (becoming mouseDown)" << llendl;
  605. }
  607. if (gSavedSettings.getBOOL("DoubleClickAutoPilot"))
  608. {
  609. if (mPick.mPickType == LLPickInfo::PICK_LAND
  610. && !mPick.mPosGlobal.isExactlyZero())
  611. {
  612. handle_go_to();
  613. return TRUE;
  614. }
  615. else if (mPick.mObjectID.notNull()
  616.  && !mPick.mPosGlobal.isExactlyZero())
  617. {
  618. handle_go_to();
  619. return TRUE;
  620. }
  621. }
  623. return FALSE;
  624. }
  626. static bool needs_tooltip(LLSelectNode* nodep)
  627. {
  628. if (!nodep) 
  629. return false;
  631. LLViewerObject* object = nodep->getObject();
  632. LLViewerObject *parent = (LLViewerObject *)object->getParent();
  633. if (object->flagHandleTouch()
  634. || (parent && parent->flagHandleTouch())
  635. || object->flagTakesMoney()
  636. || (parent && parent->flagTakesMoney())
  637. || object->flagAllowInventoryAdd()
  638. )
  639. {
  640. return true;
  641. }
  643. U8 click_action = final_click_action(object);
  644. if (click_action != 0)
  645. {
  646. return true;
  647. }
  649. if (nodep->mValid)
  650. {
  651. bool anyone_copy = anyone_copy_selection(nodep);
  652. bool for_sale = for_sale_selection(nodep);
  653. if (anyone_copy || for_sale)
  654. {
  655. return true;
  656. }
  657. }
  658. return false;
  659. }
  662. BOOL LLToolPie::handleTooltipLand(std::string line, std::string tooltip_msg)
  663. {
  664. LLViewerParcelMgr::getInstance()->setHoverParcel( mHoverPick.mPosGlobal );
  665. // 
  666. //  Do not show hover for land unless prefs are set to allow it.
  667. // 
  669. if (!gSavedSettings.getBOOL("ShowLandHoverTip")) return TRUE; 
  671. // Didn't hit an object, but since we have a land point we
  672. // must be hovering over land.
  674. LLParcel* hover_parcel = LLViewerParcelMgr::getInstance()->getHoverParcel();
  675. LLUUID owner;
  676. S32 width = 0;
  677. S32 height = 0;
  679. if ( hover_parcel )
  680. {
  681. owner = hover_parcel->getOwnerID();
  682. width = S32(LLViewerParcelMgr::getInstance()->getHoverParcelWidth());
  683. height = S32(LLViewerParcelMgr::getInstance()->getHoverParcelHeight());
  684. }
  686. // Line: "Land"
  687. line.clear();
  688. line.append(LLTrans::getString("TooltipLand"));
  689. if (hover_parcel)
  690. {
  691. line.append(hover_parcel->getName());
  692. }
  693. tooltip_msg.append(line);
  694. tooltip_msg.push_back('n');
  696. // Line: "Owner: James Linden"
  697. line.clear();
  698. line.append(LLTrans::getString("TooltipOwner") + " ");
  700. if ( hover_parcel )
  701. {
  702. std::string name;
  703. if (LLUUID::null == owner)
  704. {
  705. line.append(LLTrans::getString("TooltipPublic"));
  706. }
  707. else if (hover_parcel->getIsGroupOwned())
  708. {
  709. if (gCacheName->getGroupName(owner, name))
  710. {
  711. line.append(name);
  712. line.append(LLTrans::getString("TooltipIsGroup"));
  713. }
  714. else
  715. {
  716. line.append(LLTrans::getString("RetrievingData"));
  717. }
  718. }
  719. else if(gCacheName->getFullName(owner, name))
  720. {
  721. line.append(name);
  722. }
  723. else
  724. {
  725. line.append(LLTrans::getString("RetrievingData"));
  726. }
  727. }
  728. else
  729. {
  730. line.append(LLTrans::getString("RetrievingData"));
  731. }
  732. tooltip_msg.append(line);
  733. tooltip_msg.push_back('n');
  735. // Line: "no fly, not safe, no build"
  737. // Don't display properties for your land.  This is just
  738. // confusing, because you can do anything on your own land.
  739. if ( hover_parcel && owner != gAgent.getID() )
  740. {
  741. S32 words = 0;
  743. line.clear();
  744. // JC - Keep this in the same order as the checkboxes
  745. // on the land info panel
  746. if ( !hover_parcel->getAllowModify() )
  747. {
  748. if ( hover_parcel->getAllowGroupModify() )
  749. {
  750. line.append(LLTrans::getString("TooltipFlagGroupBuild"));
  751. }
  752. else
  753. {
  754. line.append(LLTrans::getString("TooltipFlagNoBuild"));
  755. }
  756. words++;
  757. }
  759. if ( !hover_parcel->getAllowTerraform() )
  760. {
  761. if (words) line.append(", ");
  762. line.append(LLTrans::getString("TooltipFlagNoEdit"));
  763. words++;
  764. }
  766. if ( hover_parcel->getAllowDamage() )
  767. {
  768. if (words) line.append(", ");
  769. line.append(LLTrans::getString("TooltipFlagNotSafe"));
  770. words++;
  771. }
  773. // Maybe we should reflect the estate's block fly bit here as well?  DK 12/1/04
  774. if ( !hover_parcel->getAllowFly() )
  775. {
  776. if (words) line.append(", ");
  777. line.append(LLTrans::getString("TooltipFlagNoFly"));
  778. words++;
  779. }
  781. if ( !hover_parcel->getAllowOtherScripts() )
  782. {
  783. if (words) line.append(", ");
  784. if ( hover_parcel->getAllowGroupScripts() )
  785. {
  786. line.append(LLTrans::getString("TooltipFlagGroupScripts"));
  787. }
  788. else
  789. {
  790. line.append(LLTrans::getString("TooltipFlagNoScripts"));
  791. }
  793. words++;
  794. }
  796. if (words) 
  797. {
  798. tooltip_msg.append(line);
  799. tooltip_msg.push_back('n');
  800. }
  801. }
  803. if (hover_parcel && hover_parcel->getParcelFlag(PF_FOR_SALE))
  804. {
  805. LLStringUtil::format_map_t args;
  806. args["[AMOUNT]"] = llformat("%d", hover_parcel->getSalePrice());
  807. line = LLTrans::getString("TooltipForSaleL$", args);
  808. tooltip_msg.append(line);
  809. tooltip_msg.push_back('n');
  810. }
  812. // trim last newlines
  813. if (!tooltip_msg.empty())
  814. {
  815. tooltip_msg.erase(tooltip_msg.size() - 1);
  816. LLToolTipMgr::instance().show(tooltip_msg);
  817. }
  819. return TRUE;
  820. }
  822. BOOL LLToolPie::handleTooltipObject( LLViewerObject* hover_object, std::string line, std::string tooltip_msg)
  823. {
  824. if ( hover_object->isHUDAttachment() )
  825. {
  826. // no hover tips for HUD elements, since they can obscure
  827. // what the HUD is displaying
  828. return TRUE;
  829. }
  831. if ( hover_object->isAttachment() )
  832. {
  833. // get root of attachment then parent, which is avatar
  834. LLViewerObject* root_edit = hover_object->getRootEdit();
  835. if (!root_edit)
  836. {
  837. // Strange parenting issue, don't show any text
  838. return TRUE;
  839. }
  840. hover_object = (LLViewerObject*)root_edit->getParent();
  841. if (!hover_object)
  842. {
  843. // another strange parenting issue, bail out
  844. return TRUE;
  845. }
  846. }
  848. line.clear();
  849. if (hover_object->isAvatar())
  850. {
  851. // only show tooltip if same inspector not already open
  852. LLFloater* existing_inspector = LLFloaterReg::findInstance("inspect_avatar");
  853. if (!existing_inspector 
  854. || !existing_inspector->getVisible()
  855. || existing_inspector->getKey()["avatar_id"].asUUID() != hover_object->getID())
  856. {
  857. std::string avatar_name;
  858. LLNameValue* firstname = hover_object->getNVPair("FirstName");
  859. LLNameValue* lastname =  hover_object->getNVPair("LastName");
  860. if (firstname && lastname)
  861. {
  862. avatar_name = llformat("%s %s", firstname->getString(), lastname->getString());
  863. }
  864. else
  865. {
  866. avatar_name = LLTrans::getString("TooltipPerson");
  867. }
  869. // *HACK: We may select this object, so pretend it was clicked
  870. mPick = mHoverPick;
  871. LLInspector::Params p;
  872. p.fillFrom(LLUICtrlFactory::instance().getDefaultParams<LLInspector>());
  873. p.message(avatar_name);
  874. p.image.name("Inspector_I");
  875. p.click_callback(boost::bind(showAvatarInspector, hover_object->getID()));
  876. p.visible_time_near(6.f);
  877. p.visible_time_far(3.f);
  878. p.delay_time(0.35f);
  879. p.wrap(false);
  881. LLToolTipMgr::instance().show(p);
  882. }
  883. }
  884. else
  885. {
  886. //
  887. //  We have hit a regular object (not an avatar or attachment)
  888. // 
  890. //
  891. //  Default prefs will suppress display unless the object is interactive
  892. //
  893. bool show_all_object_tips =
  894. (bool)gSavedSettings.getBOOL("ShowAllObjectHoverTip");
  895. LLSelectNode *nodep = LLSelectMgr::getInstance()->getHoverNode();
  897. // only show tooltip if same inspector not already open
  898. LLFloater* existing_inspector = LLFloaterReg::findInstance("inspect_object");
  899. if (nodep &&
  900. (!existing_inspector 
  901.  || !existing_inspector->getVisible()
  902.  || existing_inspector->getKey()["object_id"].asUUID() != hover_object->getID()))
  903. {
  904. if (nodep->mName.empty())
  905. {
  906. tooltip_msg.append(LLTrans::getString("TooltipNoName"));
  907. }
  908. else
  909. {
  910. tooltip_msg.append( nodep->mName );
  911. }
  913. bool has_media = false;
  914. bool is_time_based_media = false;
  915. bool is_web_based_media = false;
  916. bool is_media_playing = false;
  917. bool is_media_displaying = false;
  919. // Does this face have media?
  920. const LLTextureEntry* tep = hover_object->getTE(mHoverPick.mObjectFace);
  922. if(tep)
  923. {
  924. has_media = tep->hasMedia();
  925. const LLMediaEntry* mep = has_media ? tep->getMediaData() : NULL;
  926. if (mep)
  927. {
  928. viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
  929. LLPluginClassMedia* media_plugin = NULL;
  931. if (media_impl.notNull() && (media_impl->hasMedia()))
  932. {
  933. is_media_displaying = true;
  934. LLStringUtil::format_map_t args;
  936. media_plugin = media_impl->getMediaPlugin();
  937. if(media_plugin)
  938. {
  939. if(media_plugin->pluginSupportsMediaTime())
  940. {
  941. is_time_based_media = true;
  942. is_web_based_media = false;
  943. //args["[CurrentURL]"] =  media_impl->getMediaURL();
  944. is_media_playing = media_impl->isMediaPlaying();
  945. }
  946. else
  947. {
  948. is_time_based_media = false;
  949. is_web_based_media = true;
  950. //args["[CurrentURL]"] =  media_plugin->getLocation();
  951. }
  952. //tooltip_msg.append(LLTrans::getString("CurrentURL", args));
  953. }
  954. }
  955. }
  956. }
  958. // Avoid showing tip over media that's displaying
  959. // also check the primary node since sometimes it can have an action even though
  960. // the root node doesn't
  961. bool needs_tip = !is_media_displaying &&
  962. (has_media || 
  963.  needs_tooltip(nodep) || 
  964.  needs_tooltip(LLSelectMgr::getInstance()->getPrimaryHoverNode()));
  966. if (show_all_object_tips || needs_tip)
  967. {
  968. // We may select this object, so pretend it was clicked
  969. mPick = mHoverPick;
  970. LLInspector::Params p;
  971. p.fillFrom(LLUICtrlFactory::instance().getDefaultParams<LLInspector>());
  972. p.message(tooltip_msg);
  973. p.image.name("Inspector_I");
  974. p.click_callback(boost::bind(showObjectInspector, hover_object->getID(), mHoverPick.mObjectFace));
  975. p.time_based_media(is_time_based_media);
  976. p.web_based_media(is_web_based_media);
  977. p.media_playing(is_media_playing);
  978. p.click_playmedia_callback(boost::bind(playCurrentMedia, mHoverPick));
  979. p.click_homepage_callback(boost::bind(VisitHomePage, mHoverPick));
  980. p.visible_time_near(6.f);
  981. p.visible_time_far(3.f);
  982. p.delay_time(0.35f);
  983. p.wrap(false);
  985. LLToolTipMgr::instance().show(p);
  986. }
  987. }
  988. }
  990. return TRUE;
  991. }
  993. BOOL LLToolPie::handleToolTip(S32 local_x, S32 local_y, MASK mask)
  994. {
  995. if (!LLUI::sSettingGroups["config"]->getBOOL("ShowHoverTips")) return TRUE;
  996. if (!mHoverPick.isValid()) return TRUE;
  998. LLViewerObject* hover_object = mHoverPick.getObject();
  1000. // update hover object and hover parcel
  1001. LLSelectMgr::getInstance()->setHoverObject(hover_object, mHoverPick.mObjectFace);
  1004. std::string tooltip_msg;
  1005. std::string line;
  1007. if ( hover_object )
  1008. {
  1009. handleTooltipObject(hover_object, line, tooltip_msg  );
  1010. }
  1011. else if (mHoverPick.mPickType == LLPickInfo::PICK_LAND)
  1012. {
  1013. handleTooltipLand(line, tooltip_msg);
  1014. }
  1016. return TRUE;
  1017. }
  1019. static void show_inspector(const char* inspector, const char* param, const LLUUID& source_id)
  1020. {
  1021. LLSD params;
  1022. params[param] = source_id;
  1023. if (LLToolTipMgr::instance().toolTipVisible())
  1024. {
  1025. LLRect rect = LLToolTipMgr::instance().getToolTipRect();
  1026. params["pos"]["x"] = rect.mLeft;
  1027. params["pos"]["y"] = rect.mTop;
  1028. }
  1030. LLFloaterReg::showInstance(inspector, params);
  1031. }
  1034. static void show_inspector(const char* inspector,  LLSD& params)
  1035. {
  1036. if (LLToolTipMgr::instance().toolTipVisible())
  1037. {
  1038. LLRect rect = LLToolTipMgr::instance().getToolTipRect();
  1039. params["pos"]["x"] = rect.mLeft;
  1040. params["pos"]["y"] = rect.mTop;
  1041. }
  1043. LLFloaterReg::showInstance(inspector, params);
  1044. }
  1047. // static
  1048. void LLToolPie::showAvatarInspector(const LLUUID& avatar_id)
  1049. {
  1050. show_inspector("inspect_avatar", "avatar_id", avatar_id);
  1051. }
  1053. // static
  1054. void LLToolPie::showObjectInspector(const LLUUID& object_id)
  1055. {
  1056. show_inspector("inspect_object", "object_id", object_id);
  1057. }
  1060. // static
  1061. void LLToolPie::showObjectInspector(const LLUUID& object_id, const S32& object_face)
  1062. {
  1063. LLSD params;
  1064. params["object_id"] = object_id;
  1065. params["object_face"] = object_face;
  1066. show_inspector("inspect_object", params);
  1067. }
  1069. // static
  1070. void LLToolPie::playCurrentMedia(const LLPickInfo& info)
  1071. {
  1072. //FIXME: how do we handle object in different parcel than us?
  1073. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  1074. if (!parcel) return;
  1076. LLPointer<LLViewerObject> objectp = info.getObject();
  1078. // Early out cases.  Must clear media hover. 
  1079. // did not hit an object or did not hit a valid face
  1080. if ( objectp.isNull() ||
  1081. info.mObjectFace < 0 || 
  1082. info.mObjectFace >= objectp->getNumTEs() )
  1083. {
  1084. return;
  1085. }
  1087. // Does this face have media?
  1088. const LLTextureEntry* tep = objectp->getTE(info.mObjectFace);
  1089. if (!tep)
  1090. return;
  1092. const LLMediaEntry* mep = tep->hasMedia() ? tep->getMediaData() : NULL;
  1093. if(!mep)
  1094. return;
  1096. //TODO: Can you Use it? 
  1098. LLPluginClassMedia* media_plugin = NULL;
  1100. viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
  1102. if(media_impl.notNull() && media_impl->hasMedia())
  1103. {
  1104. media_plugin = media_impl->getMediaPlugin();
  1105. if (media_plugin && media_plugin->pluginSupportsMediaTime())
  1106. {
  1107. if(media_impl->isMediaPlaying())
  1108. {
  1109. media_impl->pause();
  1110. }
  1111. else 
  1112. {
  1113. media_impl->play();
  1114. }
  1115. }
  1116. }
  1119. }
  1121. // static
  1122. void LLToolPie::VisitHomePage(const LLPickInfo& info)
  1123. {
  1124. //FIXME: how do we handle object in different parcel than us?
  1125. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  1126. if (!parcel) return;
  1128. LLPointer<LLViewerObject> objectp = info.getObject();
  1130. // Early out cases.  Must clear media hover. 
  1131. // did not hit an object or did not hit a valid face
  1132. if ( objectp.isNull() ||
  1133. info.mObjectFace < 0 || 
  1134. info.mObjectFace >= objectp->getNumTEs() )
  1135. {
  1136. return;
  1137. }
  1139. // Does this face have media?
  1140. const LLTextureEntry* tep = objectp->getTE(info.mObjectFace);
  1141. if (!tep)
  1142. return;
  1144. const LLMediaEntry* mep = tep->hasMedia() ? tep->getMediaData() : NULL;
  1145. if(!mep)
  1146. return;
  1148. //TODO: Can you Use it? 
  1150. LLPluginClassMedia* media_plugin = NULL;
  1152. viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
  1154. if(media_impl.notNull() && media_impl->hasMedia())
  1155. {
  1156. media_plugin = media_impl->getMediaPlugin();
  1158. if (media_plugin && !(media_plugin->pluginSupportsMediaTime()))
  1159. {
  1160. media_impl->navigateHome();
  1161. }
  1162. }
  1163. }
  1166. void LLToolPie::handleDeselect()
  1167. {
  1168. if( hasMouseCapture() )
  1169. {
  1170. setMouseCapture( FALSE );  // Calls onMouseCaptureLost() indirectly
  1171. }
  1172. // remove temporary selection for pie menu
  1173. LLSelectMgr::getInstance()->setHoverObject(NULL);
  1174. LLSelectMgr::getInstance()->validateSelection();
  1175. }
  1177. LLTool* LLToolPie::getOverrideTool(MASK mask)
  1178. {
  1179. if (mask == MASK_CONTROL)
  1180. {
  1181. return LLToolGrab::getInstance();
  1182. }
  1183. else if (mask == (MASK_CONTROL | MASK_SHIFT))
  1184. {
  1185. return LLToolGrab::getInstance();
  1186. }
  1188. return LLTool::getOverrideTool(mask);
  1189. }
  1191. void LLToolPie::stopEditing()
  1192. {
  1193. if( hasMouseCapture() )
  1194. {
  1195. setMouseCapture( FALSE );  // Calls onMouseCaptureLost() indirectly
  1196. }
  1197. }
  1199. void LLToolPie::onMouseCaptureLost()
  1200. {
  1201. mMouseOutsideSlop = FALSE;
  1202. handleMediaMouseUp();
  1203. }
  1206. // true if x,y outside small box around start_x,start_y
  1207. BOOL LLToolPie::outsideSlop(S32 x, S32 y, S32 start_x, S32 start_y)
  1208. {
  1209. S32 dx = x - start_x;
  1210. S32 dy = y - start_y;
  1212. return (dx <= -2 || 2 <= dx || dy <= -2 || 2 <= dy);
  1213. }
  1216. void LLToolPie::render()
  1217. {
  1218. return;
  1219. }
  1221. static void handle_click_action_play()
  1222. {
  1223. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  1224. if (!parcel) return;
  1226. LLViewerMediaImpl::EMediaStatus status = LLViewerParcelMedia::getStatus();
  1227. switch(status)
  1228. {
  1229. case LLViewerMediaImpl::MEDIA_PLAYING:
  1230. LLViewerParcelMedia::pause();
  1231. break;
  1233. case LLViewerMediaImpl::MEDIA_PAUSED:
  1234. LLViewerParcelMedia::start();
  1235. break;
  1237. default:
  1238. LLViewerParcelMedia::play(parcel);
  1239. break;
  1240. }
  1241. }
  1243. bool LLToolPie::handleMediaClick(const LLPickInfo& pick)
  1244. {
  1245. //FIXME: how do we handle object in different parcel than us?
  1246. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  1247. LLPointer<LLViewerObject> objectp = pick.getObject();
  1250. if (!parcel ||
  1251. objectp.isNull() ||
  1252. pick.mObjectFace < 0 || 
  1253. pick.mObjectFace >= objectp->getNumTEs()) 
  1254. {
  1255. LLViewerMediaFocus::getInstance()->clearFocus();
  1257. return false;
  1258. }
  1260. // Does this face have media?
  1261. const LLTextureEntry* tep = objectp->getTE(pick.mObjectFace);
  1262. if(!tep)
  1263. return false;
  1265. LLMediaEntry* mep = (tep->hasMedia()) ? tep->getMediaData() : NULL;
  1266. if(!mep)
  1267. return false;
  1269. viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
  1271. if (gSavedSettings.getBOOL("MediaOnAPrimUI"))
  1272. {
  1273. if (!LLViewerMediaFocus::getInstance()->isFocusedOnFace(pick.getObject(), pick.mObjectFace) || media_impl.isNull())
  1274. {
  1275. // It's okay to give this a null impl
  1276. LLViewerMediaFocus::getInstance()->setFocusFace(pick.getObject(), pick.mObjectFace, media_impl, pick.mNormal);
  1277. }
  1278. else
  1279. {
  1280. // Make sure keyboard focus is set to the media focus object.
  1281. gFocusMgr.setKeyboardFocus(LLViewerMediaFocus::getInstance());
  1283. media_impl->mouseDown(pick.mUVCoords, gKeyboard->currentMask(TRUE));
  1284. mMediaMouseCaptureID = mep->getMediaID();
  1285. setMouseCapture(TRUE);  // This object will send a mouse-up to the media when it loses capture.
  1286. }
  1288. return true;
  1289. }
  1291. LLViewerMediaFocus::getInstance()->clearFocus();
  1293. return false;
  1294. }
  1296. bool LLToolPie::handleMediaHover(const LLPickInfo& pick)
  1297. {
  1298. //FIXME: how do we handle object in different parcel than us?
  1299. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  1300. if (!parcel) return false;
  1302. LLPointer<LLViewerObject> objectp = pick.getObject();
  1304. // Early out cases.  Must clear media hover. 
  1305. // did not hit an object or did not hit a valid face
  1306. if ( objectp.isNull() ||
  1307. pick.mObjectFace < 0 || 
  1308. pick.mObjectFace >= objectp->getNumTEs() )
  1309. {
  1310. LLViewerMediaFocus::getInstance()->clearHover();
  1311. return false;
  1312. }
  1314. // Does this face have media?
  1315. const LLTextureEntry* tep = objectp->getTE(pick.mObjectFace);
  1316. if(!tep)
  1317. return false;
  1319. const LLMediaEntry* mep = tep->hasMedia() ? tep->getMediaData() : NULL;
  1320. if (mep
  1321. && gSavedSettings.getBOOL("MediaOnAPrimUI"))
  1322. {
  1323. viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
  1325. if(media_impl.notNull())
  1326. {
  1327. // Update media hover object
  1328. if (!LLViewerMediaFocus::getInstance()->isHoveringOverFace(objectp, pick.mObjectFace))
  1329. {
  1330. LLViewerMediaFocus::getInstance()->setHoverFace(objectp, pick.mObjectFace, media_impl, pick.mNormal);
  1331. }
  1333. // If this is the focused media face, send mouse move events.
  1334. if (LLViewerMediaFocus::getInstance()->isFocusedOnFace(objectp, pick.mObjectFace))
  1335. {
  1336. media_impl->mouseMove(pick.mUVCoords, gKeyboard->currentMask(TRUE));
  1337. gViewerWindow->setCursor(media_impl->getLastSetCursor());
  1338. }
  1339. else
  1340. {
  1341. // This is not the focused face -- set the default cursor.
  1342. gViewerWindow->setCursor(UI_CURSOR_ARROW);
  1343. }
  1345. return true;
  1346. }
  1347. }
  1349. // In all other cases, clear media hover.
  1350. LLViewerMediaFocus::getInstance()->clearHover();
  1352. return false;
  1353. }
  1355. bool LLToolPie::handleMediaMouseUp()
  1356. {
  1357. bool result = false;
  1358. if(mMediaMouseCaptureID.notNull())
  1359. {
  1360. // Face media needs to know the mouse went up.
  1361. viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mMediaMouseCaptureID);
  1362. if(media_impl)
  1363. {
  1364. // This will send a mouseUp event to the plugin using the last known mouse coordinate (from a mouseDown or mouseMove), which is what we want.
  1365. media_impl->onMouseCaptureLost();
  1366. }
  1368. mMediaMouseCaptureID.setNull();
  1370. setMouseCapture(FALSE);
  1372. result = true;
  1373. }
  1375. return result;
  1376. }
  1378. static void handle_click_action_open_media(LLPointer<LLViewerObject> objectp)
  1379. {
  1380. //FIXME: how do we handle object in different parcel than us?
  1381. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  1382. if (!parcel) return;
  1384. // did we hit an object?
  1385. if (objectp.isNull()) return;
  1387. // did we hit a valid face on the object?
  1388. S32 face = LLToolPie::getInstance()->getPick().mObjectFace;
  1389. if( face < 0 || face >= objectp->getNumTEs() ) return;
  1391. // is media playing on this face?
  1392. if (LLViewerMedia::getMediaImplFromTextureID(objectp->getTE(face)->getID()) != NULL)
  1393. {
  1394. handle_click_action_play();
  1395. return;
  1396. }
  1398. std::string media_url = std::string ( parcel->getMediaURL () );
  1399. std::string media_type = std::string ( parcel->getMediaType() );
  1400. LLStringUtil::trim(media_url);
  1402. LLWeb::loadURL(media_url);
  1403. }
  1405. static ECursorType cursor_from_parcel_media(U8 click_action)
  1406. {
  1407. // HACK: This is directly referencing an impl name.  BAD!
  1408. // This can be removed when we have a truly generic media browser that only 
  1409. // builds an impl based on the type of url it is passed.
  1411. //FIXME: how do we handle object in different parcel than us?
  1412. ECursorType open_cursor = UI_CURSOR_ARROW;
  1413. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  1414. if (!parcel) return open_cursor;
  1416. std::string media_url = std::string ( parcel->getMediaURL () );
  1417. std::string media_type = std::string ( parcel->getMediaType() );
  1418. LLStringUtil::trim(media_url);
  1420. open_cursor = UI_CURSOR_TOOLMEDIAOPEN;
  1422. LLViewerMediaImpl::EMediaStatus status = LLViewerParcelMedia::getStatus();
  1423. switch(status)
  1424. {
  1425. case LLViewerMediaImpl::MEDIA_PLAYING:
  1426. return click_action == CLICK_ACTION_PLAY ? UI_CURSOR_TOOLPAUSE : open_cursor;
  1427. default:
  1428. return UI_CURSOR_TOOLPLAY;
  1429. }
  1430. }
  1433. // True if we handled the event.
  1434. BOOL LLToolPie::pickRightMouseDownCallback()
  1435. {
  1436. S32 x = mPick.mMousePt.mX;
  1437. S32 y = mPick.mMousePt.mY;
  1438. MASK mask = mPick.mKeyMask;
  1440. if (mPick.mPickType != LLPickInfo::PICK_LAND)
  1441. {
  1442. LLViewerParcelMgr::getInstance()->deselectLand();
  1443. }
  1445. // didn't click in any UI object, so must have clicked in the world
  1446. LLViewerObject *object = mPick.getObject();
  1447. LLViewerObject *parent = NULL;
  1448. if(object)
  1449. parent = object->getRootEdit();
  1451. // Can't ignore children here.
  1452. LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE);
  1454. // Spawn pie menu
  1455. if (mPick.mPickType == LLPickInfo::PICK_LAND)
  1456. {
  1457. LLParcelSelectionHandle selection = LLViewerParcelMgr::getInstance()->selectParcelAt( mPick.mPosGlobal );
  1458. gMenuHolder->setParcelSelection(selection);
  1459. gMenuLand->show(x, y);
  1461. showVisualContextMenuEffect();
  1463. }
  1464. else if (mPick.mObjectID == gAgent.getID() )
  1465. {
  1466. if(!gMenuAvatarSelf) 
  1467. {
  1468. //either at very early startup stage or at late quitting stage,
  1469. //this event is ignored.
  1470. return TRUE ;
  1471. }
  1473. gMenuAvatarSelf->show(x, y);
  1474. }
  1475. else if (object)
  1476. {
  1477. gMenuHolder->setObjectSelection(LLSelectMgr::getInstance()->getSelection());
  1479. bool is_other_attachment = (object->isAttachment() && !object->isHUDAttachment() && !object->permYouOwner());
  1480. if (object->isAvatar() 
  1481. || is_other_attachment)
  1482. {
  1483. // Find the attachment's avatar
  1484. while( object && object->isAttachment())
  1485. {
  1486. object = (LLViewerObject*)object->getParent();
  1487. llassert(object);
  1488. }
  1490. if (!object)
  1491. {
  1492. return TRUE; // unexpected, but escape
  1493. }
  1495. // Object is an avatar, so check for mute by id.
  1496. LLVOAvatar* avatar = (LLVOAvatar*)object;
  1497. std::string name = avatar->getFullname();
  1498. std::string mute_msg;
  1499. if (LLMuteList::getInstance()->isMuted(avatar->getID(), avatar->getFullname()))
  1500. {
  1501. mute_msg = LLTrans::getString("UnmuteAvatar");
  1502. }
  1503. else
  1504. {
  1505. mute_msg = LLTrans::getString("MuteAvatar");
  1506. }
  1508. if (is_other_attachment)
  1509. {
  1510. gMenuAttachmentOther->getChild<LLUICtrl>("Avatar Mute")->setValue(mute_msg);
  1511. gMenuAttachmentOther->show(x, y);
  1512. }
  1513. else
  1514. {
  1515. gMenuAvatarOther->getChild<LLUICtrl>("Avatar Mute")->setValue(mute_msg);
  1516. gMenuAvatarOther->show(x, y);
  1517. }
  1518. }
  1519. else if (object->isAttachment())
  1520. {
  1521. gMenuAttachmentSelf->show(x, y);
  1522. }
  1523. else
  1524. {
  1525. // BUG: What about chatting child objects?
  1526. std::string name;
  1527. LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode();
  1528. if (node)
  1529. {
  1530. name = node->mName;
  1531. }
  1532. std::string mute_msg;
  1533. if (LLMuteList::getInstance()->isMuted(object->getID(), name))
  1534. {
  1535. mute_msg = LLTrans::getString("UnmuteObject");
  1536. }
  1537. else
  1538. {
  1539. mute_msg = LLTrans::getString("MuteObject2");
  1540. }
  1542. gMenuHolder->childSetText("Object Mute", mute_msg);
  1543. gMenuObject->show(x, y);
  1545. showVisualContextMenuEffect();
  1546. }
  1547. }
  1549. LLTool::handleRightMouseDown(x, y, mask);
  1550. // We handled the event.
  1551. return TRUE;
  1552. }
  1554. void LLToolPie::showVisualContextMenuEffect()
  1555. {
  1556. // VEFFECT: ShowPie
  1557. LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_SPHERE, TRUE);
  1558. effectp->setPositionGlobal(mPick.mPosGlobal);
  1559. effectp->setColor(LLColor4U(gAgent.getEffectColor()));
  1560. effectp->setDuration(0.25f);
  1562. }