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

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

游戏引擎

开发平台：

C++ Builder

llpanelnearbymedia.cpp：源码内容
  1. /** 
  2.  * @file llpanelnearbymedia.cpp
  3.  * @brief Management interface for muting and controlling nearby media
  4.  *
  5.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2005-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 "llpanelnearbymedia.h"
  37. #include "llaudioengine.h"
  38. #include "llcheckboxctrl.h"
  39. #include "llcombobox.h"
  40. #include "llresizebar.h"
  41. #include "llresizehandle.h"
  42. #include "llscrolllistctrl.h"
  43. #include "llscrolllistitem.h"
  44. #include "llscrolllistcell.h"
  45. #include "llslider.h"
  46. #include "llsliderctrl.h"
  47. #include "llagent.h"
  48. #include "llagentui.h"
  49. #include "llbutton.h"
  50. #include "lltextbox.h"
  51. #include "llviewermedia.h"
  52. #include "llviewerparcelmedia.h"
  53. #include "llviewerregion.h"
  54. #include "llviewermediafocus.h"
  55. #include "llviewerparcelmgr.h"
  56. #include "llparcel.h"
  57. #include "llpluginclassmedia.h"
  58. #include "llvovolume.h"
  59. #include "llstatusbar.h"
  60. #include "llsdutil.h"
  62. #include "llfloaterreg.h"
  63. #include "llfloaterpreference.h" // for the gear icon
  64. #include "lltabcontainer.h"
  66. #include <stringize.h>
  68. extern LLControlGroup gSavedSettings;
  70. static const LLUUID PARCEL_MEDIA_LIST_ITEM_UUID = LLUUID("CAB5920F-E484-4233-8621-384CF373A321");
  71. static const LLUUID PARCEL_AUDIO_LIST_ITEM_UUID = LLUUID("DF4B020D-8A24-4B95-AB5D-CA970D694822");
  73. //
  74. // LLPanelNearByMedia
  75. //
  77. LLPanelNearByMedia::LLPanelNearByMedia()
  78. : mMediaList(NULL),
  79.   mEnableAllCtrl(NULL),
  80.   mAllMediaDisabled(false),
  81.   mDebugInfoVisible(false),
  82.   mParcelMediaItem(NULL),
  83.   mParcelAudioItem(NULL)
  84. {
  85. mParcelAudioAutoStart = gSavedSettings.getBOOL(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING) &&
  86. gSavedSettings.getBOOL("MediaTentativeAutoPlay");
  88. mCommitCallbackRegistrar.add("MediaListCtrl.EnableAll", boost::bind(&LLPanelNearByMedia::onClickEnableAll, this));
  89. mCommitCallbackRegistrar.add("MediaListCtrl.DisableAll", boost::bind(&LLPanelNearByMedia::onClickDisableAll, this));
  90. mCommitCallbackRegistrar.add("MediaListCtrl.GoMediaPrefs", boost::bind(&LLPanelNearByMedia::onAdvancedButtonClick, this));
  91. mCommitCallbackRegistrar.add("MediaListCtrl.MoreLess", boost::bind(&LLPanelNearByMedia::onMoreLess, this));
  92. mCommitCallbackRegistrar.add("SelectedMediaCtrl.Stop", boost::bind(&LLPanelNearByMedia::onClickSelectedMediaStop, this));
  93. mCommitCallbackRegistrar.add("SelectedMediaCtrl.Play", boost::bind(&LLPanelNearByMedia::onClickSelectedMediaPlay, this));
  94. mCommitCallbackRegistrar.add("SelectedMediaCtrl.Pause", boost::bind(&LLPanelNearByMedia::onClickSelectedMediaPause, this));
  95. mCommitCallbackRegistrar.add("SelectedMediaCtrl.Mute", boost::bind(&LLPanelNearByMedia::onClickSelectedMediaMute, this));
  96. mCommitCallbackRegistrar.add("SelectedMediaCtrl.Volume", boost::bind(&LLPanelNearByMedia::onCommitSelectedMediaVolume, this));
  97. mCommitCallbackRegistrar.add("SelectedMediaCtrl.Zoom", boost::bind(&LLPanelNearByMedia::onClickSelectedMediaZoom, this));
  98. mCommitCallbackRegistrar.add("SelectedMediaCtrl.Unzoom", boost::bind(&LLPanelNearByMedia::onClickSelectedMediaUnzoom, this));
  100. LLUICtrlFactory::instance().buildPanel(this, "panel_nearby_media.xml");
  101. }
  103. LLPanelNearByMedia::~LLPanelNearByMedia()
  104. {
  105. }
  107. BOOL LLPanelNearByMedia::postBuild()
  108. {
  109. LLPanel::postBuild();
  111. const S32 RESIZE_BAR_THICKNESS = 6;
  112. LLResizeBar::Params p;
  113. p.rect = LLRect(0, RESIZE_BAR_THICKNESS, getRect().getWidth(), 0);
  114. p.name = "resizebar_bottom";
  115. p.min_size = getRect().getHeight();
  116. p.side = LLResizeBar::BOTTOM;
  117. p.resizing_view = this;
  118. addChild( LLUICtrlFactory::create<LLResizeBar>(p) );
  120. p.rect = LLRect( 0, getRect().getHeight(), RESIZE_BAR_THICKNESS, 0);
  121. p.name = "resizebar_left";
  122. p.min_size = getRect().getWidth();
  123. p.side = LLResizeBar::LEFT;
  124. addChild( LLUICtrlFactory::create<LLResizeBar>(p) );
  126. LLResizeHandle::Params resize_handle_p;
  127. resize_handle_p.rect = LLRect( 0, RESIZE_HANDLE_HEIGHT, RESIZE_HANDLE_WIDTH, 0 );
  128. resize_handle_p.mouse_opaque(false);
  129. resize_handle_p.min_width(getRect().getWidth());
  130. resize_handle_p.min_height(getRect().getHeight());
  131. resize_handle_p.corner(LLResizeHandle::LEFT_BOTTOM);
  132. addChild(LLUICtrlFactory::create<LLResizeHandle>(resize_handle_p));
  134. mNearbyMediaPanel = getChild<LLUICtrl>("nearby_media_panel");
  135. mMediaList = getChild<LLScrollListCtrl>("media_list");
  136. mEnableAllCtrl = getChild<LLUICtrl>("all_nearby_media_enable_btn");
  137. mDisableAllCtrl = getChild<LLUICtrl>("all_nearby_media_disable_btn");
  138. mItemCountText = getChild<LLTextBox>("media_item_count");
  139. mShowCtrl = getChild<LLComboBox>("show_combo");
  141. // Dynamic (selection-dependent) controls
  142. mStopCtrl = getChild<LLUICtrl>("stop");
  143. mPlayCtrl = getChild<LLUICtrl>("play");
  144. mPauseCtrl = getChild<LLUICtrl>("pause");
  145. mMuteCtrl = getChild<LLUICtrl>("mute");
  146. mVolumeSliderCtrl = getChild<LLUICtrl>("volume_slider_ctrl");
  147. mZoomCtrl = getChild<LLUICtrl>("zoom");
  148. mUnzoomCtrl = getChild<LLUICtrl>("unzoom");
  149. mVolumeSlider = getChild<LLSlider>("volume_slider");
  150. mMuteBtn = getChild<LLButton>("mute_btn");
  152. mEmptyNameString = getString("empty_item_text");
  153. mParcelMediaName = getString("parcel_media_name");
  154. mParcelAudioName = getString("parcel_audio_name");
  155. mPlayingString = getString("playing_suffix");
  157. mMediaList->setDoubleClickCallback(onZoomMedia, this);
  158. mMediaList->sortByColumnIndex(PROXIMITY_COLUMN, TRUE);
  159. mMediaList->sortByColumnIndex(VISIBILITY_COLUMN, FALSE);
  161. refreshList();
  162. updateControls();
  163. updateColumns();
  165. LLView* minimized_controls = getChildView("minimized_controls");
  166. mMoreRect = getRect();
  167. mLessRect = getRect();
  168. mLessRect.mBottom = minimized_controls->getRect().mBottom;
  170. getChild<LLUICtrl>("more_less_btn")->setValue(false);
  171. onMoreLess();
  173. return TRUE;
  174. }
  176. /*virtual*/
  177. void LLPanelNearByMedia::onMouseEnter(S32 x, S32 y, MASK mask)
  178. {
  179. mHoverTimer.stop();
  180. LLPanel::onMouseEnter(x,y,mask);
  181. }
  184. /*virtual*/
  185. void LLPanelNearByMedia::onMouseLeave(S32 x, S32 y, MASK mask)
  186. {
  187. mHoverTimer.start();
  188. LLPanel::onMouseLeave(x,y,mask);
  189. }
  191. /*virtual*/ 
  192. void LLPanelNearByMedia::handleVisibilityChange ( BOOL new_visibility )
  193. {
  194. if (new_visibility)
  195. {
  196. mHoverTimer.start(); // timer will be stopped when mouse hovers over panel
  197. //gFocusMgr.setTopCtrl(this);
  198. }
  199. else
  200. {
  201. mHoverTimer.stop();
  202. //if (gFocusMgr.getTopCtrl() == this)
  203. //{
  204. // gFocusMgr.setTopCtrl(NULL);
  205. //}
  206. }
  207. }
  209. /*virtual*/ 
  210. void LLPanelNearByMedia::onTopLost ()
  211. {
  212. //LLUICtrl* new_top = gFocusMgr.getTopCtrl();
  213. //if (!new_top || !new_top->hasAncestor(this))
  214. //{
  215. // setVisible(FALSE);
  216. //}
  217. }
  219. /*virtual*/
  220. void LLPanelNearByMedia::reshape(S32 width, S32 height, BOOL called_from_parent)
  221. {
  222. LLPanel::reshape(width, height, called_from_parent);
  224. LLButton* more_less_btn = getChild<LLButton>("more_less_btn");
  225. if (more_less_btn->getValue().asBoolean())
  226. {
  227. mMoreRect = getRect();
  228. }
  230. }
  232. const F32 AUTO_CLOSE_FADE_TIME_START= 4.0f;
  233. const F32 AUTO_CLOSE_FADE_TIME_END = 5.0f;
  235. void LLPanelNearByMedia::draw()
  236. {
  237. //LLUICtrl* new_top = gFocusMgr.getTopCtrl();
  238. //if (new_top != this)
  239. //{
  240. // // reassert top ctrl
  241. // gFocusMgr.setTopCtrl(this);
  242. //}
  244. // keep bottom of panel on screen
  245. LLRect screen_rect = calcScreenRect();
  246. if (screen_rect.mBottom < 0)
  247. {
  248. LLRect new_rect = getRect();
  249. new_rect.mBottom += 0 - screen_rect.mBottom;
  250. setShape(new_rect);
  251. }
  253. mItemCountText->setValue(llformat(getString("media_item_count_format").c_str(), mMediaList->getItemCount()));
  255. refreshList();
  256. updateControls();
  258. F32 alpha = mHoverTimer.getStarted() 
  259. ? clamp_rescale(mHoverTimer.getElapsedTimeF32(), AUTO_CLOSE_FADE_TIME_START, AUTO_CLOSE_FADE_TIME_END, 1.f, 0.f)
  260. : 1.0f;
  261. LLViewDrawContext context(alpha);
  263. LLPanel::draw();
  265. if (alpha == 0.f)
  266. {
  267. setVisible(false);
  268. }
  269. }
  271. bool LLPanelNearByMedia::getParcelAudioAutoStart()
  272. {
  273. return mParcelAudioAutoStart;
  274. }
  276. LLScrollListItem* LLPanelNearByMedia::addListItem(const LLUUID &id)
  277. {
  278. if (NULL == mMediaList) return NULL;
  280. // Just set up the columns -- the values will be filled in by updateListItem().
  282. LLSD row;
  283. row["id"] = id;
  285. LLSD &columns = row["columns"];
  287. columns[CHECKBOX_COLUMN]["column"] = "media_checkbox_ctrl";
  288. columns[CHECKBOX_COLUMN]["type"] = "checkbox";
  289. //if(mDebugInfoVisible)
  290. {
  291. columns[PROXIMITY_COLUMN]["column"] = "media_proximity";
  292. columns[PROXIMITY_COLUMN]["value"] = "";
  293. columns[VISIBILITY_COLUMN]["column"] = "media_visibility";
  294. columns[VISIBILITY_COLUMN]["value"] = "";
  295. columns[CLASS_COLUMN]["column"] = "media_class";
  296. columns[CLASS_COLUMN]["type"] = "text";
  297. columns[CLASS_COLUMN]["value"] = "";
  298. }
  299. columns[NAME_COLUMN]["column"] = "media_name";
  300. columns[NAME_COLUMN]["type"] = "text";
  301. columns[NAME_COLUMN]["value"] = "";
  302. //if(mDebugInfoVisible)
  303. {
  304. columns[DEBUG_COLUMN]["column"] = "media_debug";
  305. columns[DEBUG_COLUMN]["type"] = "text";
  306. columns[DEBUG_COLUMN]["value"] = "";
  307. }
  309. LLScrollListItem* new_item = mMediaList->addElement(row);
  310. if (NULL != new_item)
  311. {
  312. LLScrollListCheck* scroll_list_check = dynamic_cast<LLScrollListCheck*>(new_item->getColumn(CHECKBOX_COLUMN));
  313. if (scroll_list_check)
  314. {
  315. LLCheckBoxCtrl *check = scroll_list_check->getCheckBox();
  316. check->setCommitCallback(boost::bind(&LLPanelNearByMedia::onCheckItem, this, _1, id));
  317. }
  318. }
  319. return new_item;
  320. }
  322. void LLPanelNearByMedia::updateListItem(LLScrollListItem* item, LLViewerMediaImpl* impl)
  323. {
  324. std::string item_name;
  325. std::string item_tooltip;
  326. std::string debug_str;
  327. LLPanelNearByMedia::MediaClass media_class = MEDIA_CLASS_ALL;
  329. getNameAndUrlHelper(impl, item_name, item_tooltip, mEmptyNameString);
  330. // Focused
  331. if (impl->hasFocus())
  332. {
  333. media_class = MEDIA_CLASS_FOCUSED;
  334. }
  335. // Is attached to another avatar?
  336. else if (impl->isAttachedToAnotherAvatar())
  337. {
  338. media_class = MEDIA_CLASS_ON_OTHERS;
  339. }
  340. // Outside agent parcel
  341. else if (!impl->isInAgentParcel())
  342. {
  343. media_class = MEDIA_CLASS_OUTSIDE_PARCEL;
  344. }
  345. else {
  346. // inside parcel
  347. media_class = MEDIA_CLASS_WITHIN_PARCEL;
  348. }
  350. if(mDebugInfoVisible)
  351. {
  352. debug_str += llformat("%g/", (float)impl->getInterest());
  354. // proximity distance is actually distance squared -- display it as straight distance.
  355. debug_str += llformat("%g/", fsqrtf(impl->getProximityDistance()));
  357. // s += llformat("%g/", (float)impl->getCPUUsage());
  358. // s += llformat("%g/", (float)impl->getApproximateTextureInterest());
  359. debug_str += llformat("%g/", (float)(NULL == impl->getSomeObject()) ? 0.0 : impl->getSomeObject()->getPixelArea());
  361. debug_str += LLPluginClassMedia::priorityToString(impl->getPriority());
  363. if(impl->hasMedia())
  364. {
  365. debug_str += '@';
  366. }
  367. else if(impl->isPlayable())
  368. {
  369. debug_str += '+';
  370. }
  371. else if(impl->isForcedUnloaded())
  372. {
  373. debug_str += '!';
  374. }
  375. }
  377. updateListItem(item,
  378.    item_name,
  379.    item_tooltip,
  380.    impl->getProximity(),
  381.    impl->isMediaDisabled(),
  382.    impl->hasMedia(),
  383.    impl->isMediaTimeBased() && impl->isMediaPlaying(),
  384.    media_class,
  385.    debug_str);
  386. }
  388. void LLPanelNearByMedia::updateListItem(LLScrollListItem* item,
  389.   const std::string &item_name,
  390.   const std::string &item_tooltip,
  391.   S32 proximity,
  392.   bool is_disabled,
  393.   bool has_media,
  394.   bool is_time_based_and_playing,
  395.   LLPanelNearByMedia::MediaClass media_class,
  396.   const std::string &debug_str)
  397. {
  398. LLScrollListCell* cell = item->getColumn(PROXIMITY_COLUMN);
  399. if(cell)
  400. {
  401. // since we are forced to sort by text, encode sort order as string
  402. std::string proximity_string = STRINGIZE(proximity);
  403. std::string old_proximity_string = cell->getValue().asString();
  404. if(proximity_string != old_proximity_string)
  405. {
  406. cell->setValue(proximity_string);
  407. mMediaList->setNeedsSort(true);
  408. }
  409. }
  411. cell = item->getColumn(CHECKBOX_COLUMN);
  412. if(cell)
  413. {
  414. cell->setValue(!is_disabled);
  415. }
  417. cell = item->getColumn(VISIBILITY_COLUMN);
  418. if(cell)
  419. {
  420. S32 old_visibility = cell->getValue();
  421. // *HACK ALERT: force ordering of Media before Audio before the rest of the list
  422. S32 new_visibility = 
  423. item->getUUID() == PARCEL_MEDIA_LIST_ITEM_UUID ? 3
  424. : item->getUUID() == PARCEL_AUDIO_LIST_ITEM_UUID ? 2
  425. : (has_media) ? 1 
  426. : ((is_disabled) ? 0
  427. : -1);
  428. cell->setValue(STRINGIZE(new_visibility));
  429. if (new_visibility != old_visibility)
  430. {
  431. mMediaList->setNeedsSort(true);
  432. }
  433. }
  435. cell = item->getColumn(NAME_COLUMN);
  436. if(cell)
  437. {
  438. std::string name = item_name;
  439. std::string old_name = cell->getValue().asString();
  440. if (has_media) 
  441. {
  442. name += " " + mPlayingString;
  443. }
  444. if (name != old_name)
  445. {
  446. cell->setValue(name);
  447. }
  448. cell->setToolTip(item_tooltip);
  450. // *TODO: Make these font styles/colors configurable via XUI
  451. U8 font_style = LLFontGL::NORMAL;
  452. LLColor4 cell_color = LLColor4::white;
  454. // Only colorize by class in debug
  455. if (mDebugInfoVisible)
  456. {
  457. switch (media_class) {
  458. case MEDIA_CLASS_FOCUSED:
  459. cell_color = LLColor4::yellow;
  460. break;
  461. case MEDIA_CLASS_ON_OTHERS:
  462. cell_color = LLColor4::red;
  463. break;
  464. case MEDIA_CLASS_OUTSIDE_PARCEL:
  465. cell_color = LLColor4::orange;
  466. break;
  467. case MEDIA_CLASS_WITHIN_PARCEL:
  468. default:
  469. break;
  470. }
  471. }
  472. if (is_disabled)
  473. {
  474. if (mDebugInfoVisible)
  475. {
  476. font_style |= LLFontGL::ITALIC;
  477. cell_color = LLColor4::black;
  478. }
  479. else {
  480. // Dim it if it is disabled
  481. cell_color.setAlpha(0.25);
  482. }
  483. }
  484. // Dim it if it isn't "showing"
  485. else if (!has_media)
  486. {
  487. cell_color.setAlpha(0.25);
  488. }
  489. // Bold it if it is time-based media and it is playing
  490. else if (is_time_based_and_playing)
  491. {
  492. if (mDebugInfoVisible) font_style |= LLFontGL::BOLD;
  493. }
  494. cell->setColor(cell_color);
  495. LLScrollListText *text_cell = dynamic_cast<LLScrollListText*> (cell);
  496. if (text_cell)
  497. {
  498. text_cell->setFontStyle(font_style);
  499. }
  500. }
  502. cell = item->getColumn(CLASS_COLUMN);
  503. if(cell)
  504. {
  505. // TODO: clean this up!
  506. cell->setValue(STRINGIZE(media_class));
  507. }
  509. if(mDebugInfoVisible)
  510. {
  511. cell = item->getColumn(DEBUG_COLUMN);
  512. if(cell)
  513. {
  514. cell->setValue(debug_str);
  515. }
  516. }
  517. }
  518.  
  519. void LLPanelNearByMedia::removeListItem(const LLUUID &id)
  520. {
  521. if (NULL == mMediaList) return;
  523. mMediaList->deleteSingleItem(mMediaList->getItemIndex(id));
  524. }
  526. void LLPanelNearByMedia::refreshParcelItems()
  527. {
  528. //
  529. // First add/remove the "fake" items Parcel Media and Parcel Audio.
  530. // These items will have special UUIDs 
  531. //    PARCEL_MEDIA_LIST_ITEM_UUID
  532. //    PARCEL_AUDIO_LIST_ITEM_UUID
  533. //
  534. // Get the filter choice.
  535. const LLSD &choice_llsd = mShowCtrl->getSelectedValue();
  536. MediaClass choice = (MediaClass)choice_llsd.asInteger();
  537. // Only show "special parcel items" if "All" or "Within" filter
  538. bool should_include = choice == MEDIA_CLASS_ALL || choice == MEDIA_CLASS_WITHIN_PARCEL;
  540. // First Parcel Media: add or remove it as necessary
  541. if (should_include && LLViewerMedia::hasParcelMedia())
  542. {
  543. // Yes, there is parcel media.
  544. if (NULL == mParcelMediaItem)
  545. {
  546. mParcelMediaItem = addListItem(PARCEL_MEDIA_LIST_ITEM_UUID);
  547. mMediaList->setNeedsSort(true);
  548. }
  549. }
  550. else {
  551. if (NULL != mParcelMediaItem) {
  552. removeListItem(PARCEL_MEDIA_LIST_ITEM_UUID);
  553. mParcelMediaItem = NULL;
  554. mMediaList->setNeedsSort(true);
  555. }
  556. }
  558. // ... then update it
  559. if (NULL != mParcelMediaItem)
  560. {
  561. std::string name, url, tooltip;
  562. getNameAndUrlHelper(LLViewerParcelMedia::getParcelMedia(), name, url, "");
  563. if (name.empty() || name == url)
  564. {
  565. tooltip = url;
  566. }
  567. else {
  568. tooltip = name + " : " + url;
  569. }
  570. LLViewerMediaImpl *impl = LLViewerParcelMedia::getParcelMedia();
  571. updateListItem(mParcelMediaItem,
  572.    mParcelMediaName,
  573.    tooltip,
  574.    -2, // Proximity closer than anything else, before Parcel Audio
  575.    impl == NULL || impl->isMediaDisabled(),
  576.    impl != NULL && !LLViewerParcelMedia::getURL().empty(),
  577.    impl != NULL && impl->isMediaTimeBased() && impl->isMediaPlaying(),
  578.    MEDIA_CLASS_ALL,
  579.    "parcel media");
  580. }
  582. // Next Parcel Audio: add or remove it as necessary
  583. if (should_include && LLViewerMedia::hasParcelAudio())
  584. {
  585. // Yes, there is parcel audio.
  586. if (NULL == mParcelAudioItem)
  587. {
  588. mParcelAudioItem = addListItem(PARCEL_AUDIO_LIST_ITEM_UUID);
  589. mMediaList->setNeedsSort(true);
  590. }
  591. }
  592. else {
  593. if (NULL != mParcelAudioItem) {
  594. removeListItem(PARCEL_AUDIO_LIST_ITEM_UUID);
  595. mParcelAudioItem = NULL;
  596. mMediaList->setNeedsSort(true);
  597. }
  598. }
  600. // ... then update it
  601. if (NULL != mParcelAudioItem)
  602. {
  603. bool is_playing = LLViewerMedia::isParcelAudioPlaying();
  604. updateListItem(mParcelAudioItem,
  605.    mParcelAudioName,
  606.    LLViewerMedia::getParcelAudioURL(),
  607.    -1, // Proximity after Parcel Media, but closer than anything else
  608.    !is_playing,
  609.    is_playing,
  610.    is_playing,
  611.    MEDIA_CLASS_ALL,
  612.    "parcel audio");
  613. }
  614. }
  616. void LLPanelNearByMedia::refreshList()
  617. {
  618. bool all_items_deleted = false;
  620. if(!mMediaList)
  621. {
  622. // None of this makes any sense if the media list isn't there.
  623. return;
  624. }
  626. // Check whether the debug column has been shown/hidden.
  627. bool debug_info_visible = gSavedSettings.getBOOL("MediaPerformanceManagerDebug");
  628. if(debug_info_visible != mDebugInfoVisible)
  629. {
  630. mDebugInfoVisible = debug_info_visible;
  632. // Clear all items so the list gets regenerated.
  633. mMediaList->deleteAllItems();
  634. mParcelAudioItem = NULL;
  635. mParcelMediaItem = NULL;
  636. all_items_deleted = true;
  638. updateColumns();
  639. }
  641. refreshParcelItems();
  643. // Get the canonical list from LLViewerMedia
  644. LLViewerMedia::impl_list impls = LLViewerMedia::getPriorityList();
  645. LLViewerMedia::impl_list::iterator priority_iter;
  647. U32 enabled_count = 0;
  648. U32 disabled_count = 0;
  650. // iterate over the impl list, creating rows as necessary.
  651. for(priority_iter = impls.begin(); priority_iter != impls.end(); priority_iter++)
  652. {
  653. LLViewerMediaImpl *impl = *priority_iter;
  655. // If we just emptied out the list, every flag needs to be reset.
  656. if(all_items_deleted)
  657. {
  658. impl->setInNearbyMediaList(false);
  659. }
  661. if (!impl->isParcelMedia())
  662. {
  663. LLUUID media_id = impl->getMediaTextureID();
  664. S32 proximity = impl->getProximity();
  665. // This is expensive (i.e. a linear search) -- don't use it here.  We now use mInNearbyMediaList instead.
  666. //S32 index = mMediaList->getItemIndex(media_id);
  667. if (proximity < 0 || !shouldShow(impl))
  668. {
  669. if (impl->getInNearbyMediaList())
  670. {
  671. // There's a row for this impl -- remove it.
  672. removeListItem(media_id);
  673. impl->setInNearbyMediaList(false);
  674. }
  675. }
  676. else
  677. {
  678. if (!impl->getInNearbyMediaList())
  679. {
  680. // We don't have a row for this impl -- add one.
  681. addListItem(media_id);
  682. impl->setInNearbyMediaList(true);
  683. }
  684. }
  685. // Update counts
  686. if (impl->isMediaDisabled())
  687. {
  688. disabled_count++;
  689. }
  690. else {
  691. enabled_count++;
  692. }
  693. }
  694. }
  695. mDisableAllCtrl->setEnabled(LLViewerMedia::isAnyMediaShowing() || 
  696. LLViewerMedia::isParcelMediaPlaying() ||
  697. LLViewerMedia::isParcelAudioPlaying());
  698. mEnableAllCtrl->setEnabled(disabled_count > 0 ||
  699.    // parcel media (if we have it, and it isn't playing, enable "start")
  700.    (LLViewerMedia::hasParcelMedia() && ! LLViewerMedia::isParcelMediaPlaying()) ||
  701.    // parcel audio (if we have it, and it isn't playing, enable "start")
  702.    (LLViewerMedia::hasParcelAudio() && ! LLViewerMedia::isParcelAudioPlaying()));
  704. // Iterate over the rows in the control, updating ones whose impl exists, and deleting ones whose impl has gone away.
  705. std::vector<LLScrollListItem*> items = mMediaList->getAllData();
  707. for (std::vector<LLScrollListItem*>::iterator item_it = items.begin();
  708. item_it != items.end();
  709. ++item_it)
  710. {
  711. LLScrollListItem* item = (*item_it);
  712. LLUUID row_id = item->getUUID();
  714. if (row_id != PARCEL_MEDIA_LIST_ITEM_UUID &&
  715. row_id != PARCEL_AUDIO_LIST_ITEM_UUID)
  716. {
  717. LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(row_id);
  718. if(impl)
  719. {
  720. updateListItem(item, impl);
  721. }
  722. else
  723. {
  724. // This item's impl has been deleted -- remove the row.
  725. // Removing the row won't throw off our iteration, since we have a local copy of the array.
  726. // We just need to make sure we don't access this item after the delete.
  727. removeListItem(row_id);
  728. }
  729. }
  730. }
  732. // Set the selection to whatever media impl the media focus/hover is on. 
  733. // This is an experiment, and can be removed by ifdefing out these 4 lines.
  734. LLUUID media_target = LLViewerMediaFocus::getInstance()->getControlsMediaID();
  735. if(media_target.notNull())
  736. {
  737. mMediaList->selectByID(media_target);
  738. }
  739. }
  741. void LLPanelNearByMedia::updateColumns()
  742. {
  743. if (!mDebugInfoVisible)
  744. {
  745. if (mMediaList->getColumn(CHECKBOX_COLUMN)) mMediaList->getColumn(VISIBILITY_COLUMN)->setWidth(-1);
  746. if (mMediaList->getColumn(VISIBILITY_COLUMN)) mMediaList->getColumn(VISIBILITY_COLUMN)->setWidth(-1);
  747. if (mMediaList->getColumn(PROXIMITY_COLUMN)) mMediaList->getColumn(PROXIMITY_COLUMN)->setWidth(-1);
  748. if (mMediaList->getColumn(CLASS_COLUMN)) mMediaList->getColumn(CLASS_COLUMN)->setWidth(-1);
  749. if (mMediaList->getColumn(DEBUG_COLUMN)) mMediaList->getColumn(DEBUG_COLUMN)->setWidth(-1);
  750. }
  751. else {
  752. if (mMediaList->getColumn(CHECKBOX_COLUMN)) mMediaList->getColumn(VISIBILITY_COLUMN)->setWidth(20);
  753. if (mMediaList->getColumn(VISIBILITY_COLUMN)) mMediaList->getColumn(VISIBILITY_COLUMN)->setWidth(20);
  754. if (mMediaList->getColumn(PROXIMITY_COLUMN)) mMediaList->getColumn(PROXIMITY_COLUMN)->setWidth(30);
  755. if (mMediaList->getColumn(CLASS_COLUMN)) mMediaList->getColumn(CLASS_COLUMN)->setWidth(20);
  756. if (mMediaList->getColumn(DEBUG_COLUMN)) mMediaList->getColumn(DEBUG_COLUMN)->setWidth(200);
  757. }
  758. }
  760. void LLPanelNearByMedia::onClickEnableAll()
  761. {
  762. LLViewerMedia::setAllMediaEnabled(true);
  763. }
  765. void LLPanelNearByMedia::onClickDisableAll()
  766. {
  767. LLViewerMedia::setAllMediaEnabled(false);
  768. }
  770. void LLPanelNearByMedia::onClickEnableParcelMedia()
  771. {
  772. if ( ! LLViewerMedia::isParcelMediaPlaying() )
  773. {
  774. LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
  775. }
  776. }
  778. void LLPanelNearByMedia::onClickDisableParcelMedia()
  779. {
  780. // This actually unloads the impl, as opposed to "stop"ping the media
  781. LLViewerParcelMedia::stop();
  782. }
  784. void LLPanelNearByMedia::onCheckItem(LLUICtrl* ctrl, const LLUUID &row_id)
  785. {
  786. LLCheckBoxCtrl* check = static_cast<LLCheckBoxCtrl*>(ctrl);
  788. setDisabled(row_id, ! check->getValue());
  789. }
  791. bool LLPanelNearByMedia::setDisabled(const LLUUID &row_id, bool disabled)
  792. {
  793. if (row_id == PARCEL_AUDIO_LIST_ITEM_UUID)
  794. {
  795. if (disabled) onClickParcelAudioStop();
  796. else onClickParcelAudioStart();
  797. return true;
  798. }
  799. else if (row_id == PARCEL_MEDIA_LIST_ITEM_UUID)
  800. {
  801. if (disabled) onClickDisableParcelMedia();
  802. else onClickEnableParcelMedia();
  803. return true;
  804. }
  805. else {
  806. LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(row_id);
  807. if(impl)
  808. {
  809. impl->setDisabled(disabled, true);
  810. return true;
  811. }
  812. }
  813. return false;
  814. }
  816. //static
  817. void LLPanelNearByMedia::onZoomMedia(void* user_data)
  818. {
  819. LLPanelNearByMedia* panelp = (LLPanelNearByMedia*)user_data;
  820. LLUUID media_id = panelp->mMediaList->getValue().asUUID();
  822. LLViewerMediaFocus::getInstance()->focusZoomOnMedia(media_id);
  823. }
  825. void LLPanelNearByMedia::onClickParcelMediaPlay()
  826. {
  827. LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
  828. }
  830. void LLPanelNearByMedia::onClickParcelMediaStop()
  831. {
  832. if (LLViewerParcelMedia::getParcelMedia())
  833. {
  834. // This stops the media playing, as opposed to unloading it like
  835. // LLViewerParcelMedia::stop() does
  836. LLViewerParcelMedia::getParcelMedia()->stop();
  837. }
  838. }
  840. void LLPanelNearByMedia::onClickParcelMediaPause()
  841. {
  842. LLViewerParcelMedia::pause();
  843. }
  845. void LLPanelNearByMedia::onClickParcelAudioStart()
  846. {
  847. // User *explicitly* started the internet stream, so keep the stream
  848. // playing and updated as they cross to other parcels etc.
  849. mParcelAudioAutoStart = true;
  851. if (!gAudiop)
  852. return;
  854. gAudiop->startInternetStream(LLViewerMedia::getParcelAudioURL());
  855. }
  857. void LLPanelNearByMedia::onClickParcelAudioPlay()
  858. {
  859. // User *explicitly* started the internet stream, so keep the stream
  860. // playing and updated as they cross to other parcels etc.
  861. mParcelAudioAutoStart = true;
  863. if (!gAudiop)
  864. return;
  866. if (LLAudioEngine::AUDIO_PAUSED == gAudiop->isInternetStreamPlaying())
  867. {
  868. // 'false' means unpause
  869. gAudiop->pauseInternetStream(false);
  870. }
  871. else {
  872. gAudiop->startInternetStream(LLViewerMedia::getParcelAudioURL());
  873. }
  874. }
  876. void LLPanelNearByMedia::onClickParcelAudioStop()
  877. {
  878. // User *explicitly* stopped the internet stream, so don't
  879. // re-start audio when i.e. they move to another parcel, until
  880. // they explicitly start it again.
  881. mParcelAudioAutoStart = false;
  883. if (!gAudiop)
  884. return;
  886. gAudiop->stopInternetStream();
  887. }
  889. void LLPanelNearByMedia::onClickParcelAudioPause()
  890. {
  891. if (!gAudiop)
  892. return;
  894. // 'true' means pause
  895. gAudiop->pauseInternetStream(true);
  896. }
  898. bool LLPanelNearByMedia::shouldShow(LLViewerMediaImpl* impl)
  899. {
  900. const LLSD &choice_llsd = mShowCtrl->getSelectedValue();
  901. MediaClass choice = (MediaClass)choice_llsd.asInteger();
  903. switch (choice)
  904. {
  905. case MEDIA_CLASS_ALL:
  906. return true;
  907. break;
  908. case MEDIA_CLASS_WITHIN_PARCEL:
  909. return impl->isInAgentParcel();
  910. break;
  911. case MEDIA_CLASS_OUTSIDE_PARCEL:
  912. return ! impl->isInAgentParcel();
  913. break;
  914. case MEDIA_CLASS_ON_OTHERS:
  915. return impl->isAttachedToAnotherAvatar();
  916. break;
  917. default:
  918. break;
  919. }
  920. return true;
  921. }
  923. void LLPanelNearByMedia::onAdvancedButtonClick()
  924. {
  925. // bring up the prefs floater
  926. LLFloaterPreference* prefsfloater = dynamic_cast<LLFloaterPreference*>(LLFloaterReg::showInstance("preferences"));
  927. if (prefsfloater)
  928. {
  929. // grab the 'audio' panel from the preferences floater and
  930. // bring it the front!
  931. LLTabContainer* tabcontainer = prefsfloater->getChild<LLTabContainer>("pref core");
  932. LLPanel* audiopanel = prefsfloater->getChild<LLPanel>("audio");
  933. if (tabcontainer && audiopanel)
  934. {
  935. tabcontainer->selectTabPanel(audiopanel);
  936. }
  937. }
  938. }
  940. void LLPanelNearByMedia::onMoreLess()
  941. {
  942. bool is_more = getChild<LLUICtrl>("more_less_btn")->getValue();
  943. mNearbyMediaPanel->setVisible(is_more);
  945. // enable resizing when expanded
  946. getChildView("resizebar_bottom")->setEnabled(is_more);
  948. LLRect new_rect = is_more ? mMoreRect : mLessRect;
  949. new_rect.translate(getRect().mRight - new_rect.mRight, getRect().mTop - new_rect.mTop);
  951. setShape(new_rect);
  952. }
  954. void LLPanelNearByMedia::updateControls()
  955. {
  956. LLUUID selected_media_id = mMediaList->getValue().asUUID();
  958. if (selected_media_id == PARCEL_AUDIO_LIST_ITEM_UUID)
  959. {
  960. showTimeBasedControls(LLViewerMedia::isParcelAudioPlaying(),
  961.   false, // include_zoom
  962.   false, // is_zoomed
  963.   gSavedSettings.getBOOL("MuteMusic"), 
  964.   gSavedSettings.getF32("AudioLevelMusic") );
  965. }
  966. else if (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID)
  967. {
  968. if (!LLViewerMedia::hasParcelMedia())
  969. {
  970. // Shouldn't happen, but do this anyway
  971. showDisabledControls();
  972. }
  973. else {
  974. LLViewerMediaImpl* impl = LLViewerParcelMedia::getParcelMedia();
  975. if (NULL == impl)
  976. {
  977. // Just means it hasn't started yet
  978. showBasicControls(false, false, false);
  979. }
  980. else if (impl->isMediaTimeBased())
  981. {
  982. showTimeBasedControls(impl->isMediaPlaying(), 
  983.   false, // include_zoom
  984.   false, // is_zoomed
  985.   impl->getVolume() == 0.0,
  986.   impl->getVolume() );
  987. }
  988. else {
  989. // non-time-based parcel media
  990. showBasicControls(LLViewerMedia::isParcelMediaPlaying(), false, false);
  991. }
  992. }
  993. }
  994. else {
  995. LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
  997. if (NULL == impl)
  998. {
  999. showDisabledControls();
  1000. }
  1001. else {
  1002. if (impl->isMediaTimeBased())
  1003. {
  1004. showTimeBasedControls(impl->isMediaPlaying(), 
  1005.   ! impl->isParcelMedia(),  // include_zoom
  1006.   LLViewerMediaFocus::getInstance()->isZoomed(),
  1007.   impl->getVolume() == 0.0,
  1008.   impl->getVolume());
  1009. }
  1010. else {
  1011. showBasicControls(!impl->isMediaDisabled(), 
  1012.   ! impl->isParcelMedia(),  // include_zoom
  1013.   LLViewerMediaFocus::getInstance()->isZoomed());
  1014. }
  1015. }
  1016. }
  1017. }
  1019. void LLPanelNearByMedia::showBasicControls(bool playing, bool include_zoom, bool is_zoomed)
  1020. {
  1021. mStopCtrl->setVisible(playing);
  1022. mPlayCtrl->setVisible(!playing);
  1023. mPauseCtrl->setVisible(false);
  1024. mMuteCtrl->setVisible(false);
  1025. mVolumeSliderCtrl->setVisible(false);
  1026. mZoomCtrl->setVisible(include_zoom && !is_zoomed);
  1027. mUnzoomCtrl->setVisible(include_zoom && is_zoomed);
  1028. mStopCtrl->setEnabled(true);
  1029. mZoomCtrl->setEnabled(true);
  1030. }
  1032. void LLPanelNearByMedia::showTimeBasedControls(bool playing, bool include_zoom, bool is_zoomed, bool muted, F32 volume)
  1033. {
  1034. mStopCtrl->setVisible(true);
  1035. mPlayCtrl->setVisible(!playing);
  1036. mPauseCtrl->setVisible(playing);
  1037. mMuteCtrl->setVisible(true);
  1038. mVolumeSliderCtrl->setVisible(true);
  1039. mZoomCtrl->setVisible(include_zoom);
  1040. mZoomCtrl->setVisible(include_zoom && !is_zoomed);
  1041. mUnzoomCtrl->setVisible(include_zoom && is_zoomed);
  1042. mStopCtrl->setEnabled(true);
  1043. mZoomCtrl->setEnabled(true);
  1044. mMuteBtn->setValue(muted);
  1045. mVolumeSlider->setValue(volume);
  1046. }
  1048. void LLPanelNearByMedia::showDisabledControls()
  1049. {
  1050. mStopCtrl->setVisible(true);
  1051. mPlayCtrl->setVisible(false);
  1052. mPauseCtrl->setVisible(false);
  1053. mMuteCtrl->setVisible(false);
  1054. mVolumeSliderCtrl->setVisible(false);
  1055. mZoomCtrl->setVisible(true);
  1056. mUnzoomCtrl->setVisible(false);
  1057. mStopCtrl->setEnabled(false);
  1058. mZoomCtrl->setEnabled(false);
  1059. }
  1061. void LLPanelNearByMedia::onClickSelectedMediaStop()
  1062. {
  1063. setDisabled(mMediaList->getValue().asUUID(), true);
  1064. }
  1066. void LLPanelNearByMedia::onClickSelectedMediaPlay()
  1067. {
  1068. LLUUID selected_media_id = mMediaList->getValue().asUUID();
  1070. // First enable it
  1071. setDisabled(selected_media_id, false);
  1073. // Special code to make play "unpause" if time-based and playing
  1074. if (selected_media_id != PARCEL_AUDIO_LIST_ITEM_UUID)
  1075. {
  1076. LLViewerMediaImpl *impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
  1077. ((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
  1078. if (NULL != impl && impl->isMediaTimeBased() && impl->isMediaPaused())
  1079. {
  1080. // Aha!  It's really time-based media that's paused, so unpause
  1081. impl->play();
  1082. return;
  1083. }
  1084. else if (impl->isParcelMedia())
  1085. {
  1086. LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
  1087. }
  1088. }
  1089. }
  1091. void LLPanelNearByMedia::onClickSelectedMediaPause()
  1092. {
  1093. LLUUID selected_media_id = mMediaList->getValue().asUUID();
  1094. if (selected_media_id == PARCEL_AUDIO_LIST_ITEM_UUID)
  1095. {
  1096. onClickParcelAudioPause();
  1097. }
  1098. else if (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) 
  1099. {
  1100. onClickParcelMediaPause();
  1101. }
  1102. else {
  1103. LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
  1104. if (NULL != impl && impl->isMediaTimeBased() && impl->isMediaPlaying())
  1105. {
  1106. impl->pause();
  1107. }
  1108. }
  1109. }
  1111. void LLPanelNearByMedia::onClickSelectedMediaMute()
  1112. {
  1113. LLUUID selected_media_id = mMediaList->getValue().asUUID();
  1114. if (selected_media_id == PARCEL_AUDIO_LIST_ITEM_UUID)
  1115. {
  1116. gSavedSettings.setBOOL("MuteMusic", mMuteBtn->getValue());
  1117. }
  1118. else {
  1119. LLViewerMediaImpl* impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
  1120. ((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
  1121. if (NULL != impl && impl->isMediaTimeBased())
  1122. {
  1123. F32 volume = impl->getVolume();
  1124. if(volume > 0.0)
  1125. {
  1126. impl->setVolume(0.0);
  1127. }
  1128. else if (mVolumeSlider->getValueF32() == 0.0)
  1129. {
  1130. impl->setVolume(1.0);
  1131. mVolumeSlider->setValue(1.0);
  1132. }
  1133. else 
  1134. {
  1135. impl->setVolume(mVolumeSlider->getValueF32());
  1136. }
  1137. }
  1138. }
  1139. }
  1141. void LLPanelNearByMedia::onCommitSelectedMediaVolume()
  1142. {
  1143. LLUUID selected_media_id = mMediaList->getValue().asUUID();
  1144. if (selected_media_id == PARCEL_AUDIO_LIST_ITEM_UUID)
  1145. {
  1146. F32 vol = mVolumeSlider->getValueF32();
  1147. gSavedSettings.setF32("AudioLevelMusic", vol);
  1148. }
  1149. else {
  1150. LLViewerMediaImpl* impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
  1151. ((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
  1152. if (NULL != impl && impl->isMediaTimeBased())
  1153. {
  1154. impl->setVolume(mVolumeSlider->getValueF32());
  1155. }
  1156. }
  1157. }
  1159. void LLPanelNearByMedia::onClickSelectedMediaZoom()
  1160. {
  1161. LLUUID selected_media_id = mMediaList->getValue().asUUID();
  1162. if (selected_media_id == PARCEL_AUDIO_LIST_ITEM_UUID || selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID)
  1163. return;
  1164. LLViewerMediaFocus::getInstance()->focusZoomOnMedia(selected_media_id);
  1165. }
  1167. void LLPanelNearByMedia::onClickSelectedMediaUnzoom()
  1168. {
  1169. LLViewerMediaFocus::getInstance()->unZoom();
  1170. }
  1173. // static
  1174. void LLPanelNearByMedia::getNameAndUrlHelper(LLViewerMediaImpl* impl, std::string& name, std::string & url, const std::string &defaultName)
  1175. {
  1176. if (NULL == impl) return;
  1178. name = impl->getName();
  1179. url = impl->getCurrentMediaURL(); // This is the URL the media impl actually has loaded
  1180. if (url.empty())
  1181. {
  1182. url = impl->getMediaEntryURL(); // This is the current URL from the media data
  1183. }
  1184. if (url.empty())
  1185. {
  1186. url = impl->getHomeURL(); // This is the home URL from the media data
  1187. }
  1188. if (name.empty())
  1189. {
  1190. name = url;
  1191. }
  1192. if (name.empty())
  1193. {
  1194. name = defaultName;
  1195. }
  1196. }