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

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

游戏引擎

开发平台：

C++ Builder

llpanelprimmediacontrols.cpp：源码内容
  1. /** 
  2.  * @file llpanelprimmediacontrols.cpp
  3.  * @brief media controls popup panel
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-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. //LLPanelPrimMediaControls
  36. #include "llagent.h"
  37. #include "llparcel.h"
  38. #include "llpanel.h"
  39. #include "llselectmgr.h"
  40. #include "llmediaentry.h"
  41. #include "llrender.h"
  42. #include "lldrawable.h"
  43. #include "llviewerwindow.h"
  44. #include "lluictrlfactory.h"
  45. #include "llbutton.h"
  46. #include "llface.h"
  47. #include "llcombobox.h"
  48. #include "lllayoutstack.h"
  49. #include "llslider.h"
  50. #include "llhudview.h"
  51. #include "lliconctrl.h"
  52. #include "lltoolpie.h"
  53. #include "llviewercamera.h"
  54. #include "llviewerobjectlist.h"
  55. #include "llpanelprimmediacontrols.h"
  56. #include "llpluginclassmedia.h"
  57. #include "llprogressbar.h"
  58. #include "llsliderctrl.h"
  59. #include "llstring.h"
  60. #include "llviewercontrol.h"
  61. #include "llviewerdisplay.h"
  62. #include "llviewerparcelmgr.h"
  63. #include "llviewermedia.h"
  64. #include "llviewermediafocus.h"
  65. #include "llvovolume.h"
  66. #include "llweb.h"
  67. #include "llwindow.h"
  69. #include "llfloatertools.h"  // to enable hide if build tools are up
  71. // Functions pulled from pipeline.cpp
  72. glh::matrix4f glh_get_current_modelview();
  73. glh::matrix4f glh_get_current_projection();
  74. // Functions pulled from llviewerdisplay.cpp
  75. bool get_hud_matrices(glh::matrix4f &proj, glh::matrix4f &model);
  77. // Warning: make sure these two match!
  78. const LLPanelPrimMediaControls::EZoomLevel LLPanelPrimMediaControls::kZoomLevels[] = { ZOOM_NONE, ZOOM_MEDIUM };
  79. const int LLPanelPrimMediaControls::kNumZoomLevels = 2;
  81. //
  82. // LLPanelPrimMediaControls
  83. //
  85. LLPanelPrimMediaControls::LLPanelPrimMediaControls() : 
  86. mAlpha(1.f),
  87. mCurrentURL(""),
  88. mPreviousURL(""),
  89. mPauseFadeout(false),
  90. mUpdateSlider(true),
  91. mClearFaceOnFade(false),
  92. mCurrentRate(0.0),
  93. mMovieDuration(0.0),
  94. mTargetObjectID(LLUUID::null),
  95. mTargetObjectFace(0),
  96. mTargetImplID(LLUUID::null),
  97. mTargetObjectNormal(LLVector3::zero),
  98. mZoomObjectID(LLUUID::null),
  99. mZoomObjectFace(0),
  100. mVolumeSliderVisible(0)
  101. {
  102. mCommitCallbackRegistrar.add("MediaCtrl.Close", boost::bind(&LLPanelPrimMediaControls::onClickClose, this));
  103. mCommitCallbackRegistrar.add("MediaCtrl.Back", boost::bind(&LLPanelPrimMediaControls::onClickBack, this));
  104. mCommitCallbackRegistrar.add("MediaCtrl.Forward", boost::bind(&LLPanelPrimMediaControls::onClickForward, this));
  105. mCommitCallbackRegistrar.add("MediaCtrl.Home", boost::bind(&LLPanelPrimMediaControls::onClickHome, this));
  106. mCommitCallbackRegistrar.add("MediaCtrl.Stop", boost::bind(&LLPanelPrimMediaControls::onClickStop, this));
  107. mCommitCallbackRegistrar.add("MediaCtrl.MediaStop", boost::bind(&LLPanelPrimMediaControls::onClickMediaStop, this));
  108. mCommitCallbackRegistrar.add("MediaCtrl.Reload", boost::bind(&LLPanelPrimMediaControls::onClickReload, this));
  109. mCommitCallbackRegistrar.add("MediaCtrl.Play", boost::bind(&LLPanelPrimMediaControls::onClickPlay, this));
  110. mCommitCallbackRegistrar.add("MediaCtrl.Pause", boost::bind(&LLPanelPrimMediaControls::onClickPause, this));
  111. mCommitCallbackRegistrar.add("MediaCtrl.Open", boost::bind(&LLPanelPrimMediaControls::onClickOpen, this));
  112. mCommitCallbackRegistrar.add("MediaCtrl.Zoom", boost::bind(&LLPanelPrimMediaControls::onClickZoom, this));
  113. mCommitCallbackRegistrar.add("MediaCtrl.CommitURL", boost::bind(&LLPanelPrimMediaControls::onCommitURL, this));
  114. mCommitCallbackRegistrar.add("MediaCtrl.JumpProgress", boost::bind(&LLPanelPrimMediaControls::onCommitSlider, this));
  115. mCommitCallbackRegistrar.add("MediaCtrl.CommitVolumeUp", boost::bind(&LLPanelPrimMediaControls::onCommitVolumeUp, this));
  116. mCommitCallbackRegistrar.add("MediaCtrl.CommitVolumeDown", boost::bind(&LLPanelPrimMediaControls::onCommitVolumeDown, this));
  117. mCommitCallbackRegistrar.add("MediaCtrl.Volume", boost::bind(&LLPanelPrimMediaControls::onCommitVolumeSlider, this));
  118. mCommitCallbackRegistrar.add("MediaCtrl.ToggleMute", boost::bind(&LLPanelPrimMediaControls::onToggleMute, this));
  119. mCommitCallbackRegistrar.add("MediaCtrl.ShowVolumeSlider", boost::bind(&LLPanelPrimMediaControls::showVolumeSlider, this));
  120. mCommitCallbackRegistrar.add("MediaCtrl.HideVolumeSlider", boost::bind(&LLPanelPrimMediaControls::hideVolumeSlider, this));
  121. mCommitCallbackRegistrar.add("MediaCtrl.SkipBack", boost::bind(&LLPanelPrimMediaControls::onClickSkipBack, this));
  122. mCommitCallbackRegistrar.add("MediaCtrl.SkipForward", boost::bind(&LLPanelPrimMediaControls::onClickSkipForward, this));
  124. LLUICtrlFactory::getInstance()->buildPanel(this, "panel_prim_media_controls.xml");
  125. mInactivityTimer.reset();
  126. mFadeTimer.stop();
  127. mCurrentZoom = ZOOM_NONE;
  128. mScrollState = SCROLL_NONE;
  130. mPanelHandle.bind(this);
  132. mInactiveTimeout = gSavedSettings.getF32("MediaControlTimeout");
  133. mControlFadeTime = gSavedSettings.getF32("MediaControlFadeTime");
  134. }
  136. LLPanelPrimMediaControls::~LLPanelPrimMediaControls()
  137. {
  138. }
  140. BOOL LLPanelPrimMediaControls::postBuild()
  141. {
  142. mMediaRegion = getChild<LLView>("media_region");
  143. mBackCtrl = getChild<LLUICtrl>("back");
  144. mFwdCtrl = getChild<LLUICtrl>("fwd");
  145. mReloadCtrl = getChild<LLUICtrl>("reload");
  146. mPlayCtrl = getChild<LLUICtrl>("play");
  147. mPauseCtrl = getChild<LLUICtrl>("pause");
  148. mStopCtrl = getChild<LLUICtrl>("stop");
  149. mMediaStopCtrl = getChild<LLUICtrl>("media_stop");
  150. mHomeCtrl = getChild<LLUICtrl>("home");
  151. mUnzoomCtrl = getChild<LLUICtrl>("close"); // This is actually "unzoom" 
  152. mOpenCtrl = getChild<LLUICtrl>("new_window");
  153. mZoomCtrl = getChild<LLUICtrl>("zoom_frame");
  154. mMediaProgressPanel = getChild<LLPanel>("media_progress_indicator");
  155. mMediaProgressBar = getChild<LLProgressBar>("media_progress_bar");
  156. mMediaAddressCtrl = getChild<LLUICtrl>("media_address");
  157. mMediaAddress = getChild<LLUICtrl>("media_address_url");
  158. mMediaPlaySliderPanel = getChild<LLUICtrl>("media_play_position");
  159. mMediaPlaySliderCtrl = getChild<LLUICtrl>("media_play_slider");
  160. mSkipFwdCtrl = getChild<LLUICtrl>("skip_forward");
  161. mSkipBackCtrl = getChild<LLUICtrl>("skip_back");
  162. mVolumeCtrl = getChild<LLUICtrl>("media_volume");
  163. mMuteBtn = getChild<LLButton>("media_mute_button");
  164. mVolumeSliderCtrl       = getChild<LLSliderCtrl>("volume_slider");
  165. mWhitelistIcon = getChild<LLIconCtrl>("media_whitelist_flag");
  166. mSecureLockIcon = getChild<LLIconCtrl>("media_secure_lock_flag");
  167. mMediaControlsStack = getChild<LLLayoutStack>("media_controls");
  168. mLeftBookend = getChild<LLUICtrl>("left_bookend");
  169. mRightBookend = getChild<LLUICtrl>("right_bookend");
  170. mBackgroundImage = LLUI::getUIImage(getString("control_background_image_name"));
  171. mVolumeSliderBackgroundImage = LLUI::getUIImage(getString("control_background_image_name"));
  172. LLStringUtil::convertToF32(getString("skip_step"), mSkipStep);
  173. LLStringUtil::convertToS32(getString("min_width"), mMinWidth);
  174. LLStringUtil::convertToS32(getString("min_height"), mMinHeight);
  175. LLStringUtil::convertToF32(getString("zoom_near_padding"), mZoomNearPadding);
  176. LLStringUtil::convertToF32(getString("zoom_medium_padding"), mZoomMediumPadding);
  177. LLStringUtil::convertToF32(getString("zoom_far_padding"), mZoomFarPadding);
  178. LLStringUtil::convertToS32(getString("top_world_view_avoid_zone"), mTopWorldViewAvoidZone);
  180. // These are currently removed...but getChild creates a "dummy" widget.
  181. // This class handles them missing.
  182. mMediaPanelScroll = findChild<LLUICtrl>("media_panel_scroll");
  183. mScrollUpCtrl = findChild<LLButton>("scrollup");
  184. mScrollLeftCtrl = findChild<LLButton>("scrollleft");
  185. mScrollRightCtrl = findChild<LLButton>("scrollright");
  186. mScrollDownCtrl = findChild<LLButton>("scrolldown");
  188. if (mScrollUpCtrl)
  189. {
  190. mScrollUpCtrl->setClickedCallback(onScrollUp, this);
  191. mScrollUpCtrl->setHeldDownCallback(onScrollUpHeld, this);
  192. mScrollUpCtrl->setMouseUpCallback(onScrollStop, this);
  193. }
  194. if (mScrollLeftCtrl)
  195. {
  196. mScrollLeftCtrl->setClickedCallback(onScrollLeft, this);
  197. mScrollLeftCtrl->setHeldDownCallback(onScrollLeftHeld, this);
  198. mScrollLeftCtrl->setMouseUpCallback(onScrollStop, this);
  199. }
  200. if (mScrollRightCtrl)
  201. {
  202. mScrollRightCtrl->setClickedCallback(onScrollRight, this);
  203. mScrollRightCtrl->setHeldDownCallback(onScrollRightHeld, this);
  204. mScrollRightCtrl->setMouseUpCallback(onScrollStop, this);
  205. }
  206. if (mScrollDownCtrl)
  207. {
  208. mScrollDownCtrl->setClickedCallback(onScrollDown, this);
  209. mScrollDownCtrl->setHeldDownCallback(onScrollDownHeld, this);
  210. mScrollDownCtrl->setMouseUpCallback(onScrollStop, this);
  211. }
  213. mMediaAddress->setFocusReceivedCallback(boost::bind(&LLPanelPrimMediaControls::onInputURL, _1, this ));
  215. mCurrentZoom = ZOOM_NONE;
  216. // clicks on buttons do not remove keyboard focus from media
  217. setIsChrome(TRUE);
  218. return TRUE;
  219. }
  221. void LLPanelPrimMediaControls::setMediaFace(LLPointer<LLViewerObject> objectp, S32 face, viewer_media_t media_impl, LLVector3 pick_normal)
  222. {
  223. if (media_impl.notNull() && objectp.notNull())
  224. {
  225. LLUUID prev_id = mTargetImplID;
  226. mTargetImplID = media_impl->getMediaTextureID();
  227. mTargetObjectID = objectp->getID();
  228. mTargetObjectFace = face;
  229. mTargetObjectNormal = pick_normal;
  230. mClearFaceOnFade = false;
  232. if (prev_id != mTargetImplID)
  233. mVolumeSliderCtrl->setValue(media_impl->getVolume());
  234. }
  235. else
  236. {
  237. // This happens on a timer now.
  238. // mTargetImplID = LLUUID::null;
  239. // mTargetObjectID = LLUUID::null;
  240. // mTargetObjectFace = 0;
  241. mClearFaceOnFade = true;
  242. }
  244. updateShape();
  245. }
  247. void LLPanelPrimMediaControls::focusOnTarget()
  248. {
  249. // Sets the media focus to the current target of the LLPanelPrimMediaControls.
  250. // This is how we transition from hover to focus when the user clicks on a control.
  251. LLViewerMediaImpl* media_impl = getTargetMediaImpl();
  252. if(media_impl)
  253. {
  254. if(!media_impl->hasFocus())
  255. {
  256. // The current target doesn't have media focus -- focus on it.
  257. LLViewerObject* objectp = getTargetObject();
  258. LLViewerMediaFocus::getInstance()->setFocusFace(objectp, mTargetObjectFace, media_impl, mTargetObjectNormal);
  259. }
  260. }
  261. }
  263. LLViewerMediaImpl* LLPanelPrimMediaControls::getTargetMediaImpl()
  264. {
  265. return LLViewerMedia::getMediaImplFromTextureID(mTargetImplID);
  266. }
  268. LLViewerObject* LLPanelPrimMediaControls::getTargetObject()
  269. {
  270. return gObjectList.findObject(mTargetObjectID);
  271. }
  273. LLPluginClassMedia* LLPanelPrimMediaControls::getTargetMediaPlugin()
  274. {
  275. LLViewerMediaImpl* impl = getTargetMediaImpl();
  276. if(impl && impl->hasMedia())
  277. {
  278. return impl->getMediaPlugin();
  279. }
  281. return NULL;
  282. }
  284. void LLPanelPrimMediaControls::updateShape()
  285. {
  286. LLViewerMediaImpl* media_impl = getTargetMediaImpl();
  287. LLViewerObject* objectp = getTargetObject();
  289. if(!media_impl || gFloaterTools->getVisible())
  290. {
  291. setVisible(FALSE);
  292. return;
  293. }
  295. LLPluginClassMedia* media_plugin = NULL;
  296. if(media_impl->hasMedia())
  297. {
  298. media_plugin = media_impl->getMediaPlugin();
  299. }
  301. LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  303. bool can_navigate = parcel->getMediaAllowNavigate();
  304. bool enabled = false;
  305. bool is_zoomed = (mCurrentZoom != ZOOM_NONE) && (mTargetObjectID == mZoomObjectID) && (mTargetObjectFace == mZoomObjectFace);
  306. // There is no such thing as "has_focus" being different from normal controls set
  307. // anymore (as of user feedback from bri 10/09).  So we cheat here and force 'has_focus'
  308. // to 'true' (or, actually, we use a setting)
  309. bool has_focus = (gSavedSettings.getBOOL("PrimMediaControlsUseHoverControlSet")) ? media_impl->hasFocus() : true;
  310. setVisible(enabled);
  312. if (objectp)
  313. {
  314. bool mini_controls = false;
  315. LLMediaEntry *media_data = objectp->getTE(mTargetObjectFace)->getMediaData();
  316. if (media_data && NULL != dynamic_cast<LLVOVolume*>(objectp))
  317. {
  318. // Don't show the media controls if we do not have permissions
  319. enabled = dynamic_cast<LLVOVolume*>(objectp)->hasMediaPermission(media_data, LLVOVolume::MEDIA_PERM_CONTROL);
  320. mini_controls = (LLMediaEntry::MINI == media_data->getControls());
  321. }
  322. const bool is_hud = objectp->isHUDAttachment();
  324. //
  325. // Set the state of the buttons
  326. //
  328. // XXX RSP: TODO: FIXME: clean this up so that it is clearer what mode we are in,
  329. // and that only the proper controls get made visible/enabled according to that mode. 
  330. mBackCtrl->setVisible(has_focus);
  331. mFwdCtrl->setVisible(has_focus);
  332. mReloadCtrl->setVisible(has_focus);
  333. mStopCtrl->setVisible(false);
  334. mHomeCtrl->setVisible(has_focus);
  335. mZoomCtrl->setVisible(!is_zoomed);
  336. mUnzoomCtrl->setVisible(is_zoomed);
  337. mOpenCtrl->setVisible(true);
  338. mMediaAddressCtrl->setVisible(has_focus && !mini_controls);
  339. mMediaPlaySliderPanel->setVisible(has_focus && !mini_controls);
  340. mVolumeCtrl->setVisible(false);
  342. mWhitelistIcon->setVisible(!mini_controls && (media_data)?media_data->getWhiteListEnable():false);
  343. // Disable zoom if HUD
  344. mZoomCtrl->setEnabled(!is_hud);
  345. mUnzoomCtrl->setEnabled(!is_hud);
  346. mSecureLockIcon->setVisible(false);
  347. mCurrentURL = media_impl->getCurrentMediaURL();
  349. mBackCtrl->setEnabled((media_impl != NULL) && media_impl->canNavigateBack() && can_navigate);
  350. mFwdCtrl->setEnabled((media_impl != NULL) && media_impl->canNavigateForward() && can_navigate);
  351. mStopCtrl->setEnabled(has_focus && can_navigate);
  352. mHomeCtrl->setEnabled(has_focus && can_navigate);
  353. LLPluginClassMediaOwner::EMediaStatus result = ((media_impl != NULL) && media_impl->hasMedia()) ? media_plugin->getStatus() : LLPluginClassMediaOwner::MEDIA_NONE;
  355. if(media_plugin && media_plugin->pluginSupportsMediaTime())
  356. {
  357. mReloadCtrl->setEnabled(false);
  358. mReloadCtrl->setVisible(false);
  359. mMediaStopCtrl->setVisible(has_focus);
  360. mHomeCtrl->setVisible(has_focus);
  361. mBackCtrl->setVisible(false);
  362. mFwdCtrl->setVisible(false);
  363. mMediaAddressCtrl->setVisible(false);
  364. mMediaAddressCtrl->setEnabled(false);
  365. mMediaPlaySliderPanel->setVisible(has_focus && !mini_controls);
  366. mMediaPlaySliderPanel->setEnabled(has_focus && !mini_controls);
  367. mSkipFwdCtrl->setVisible(has_focus && !mini_controls);
  368. mSkipFwdCtrl->setEnabled(has_focus && !mini_controls);
  369. mSkipBackCtrl->setVisible(has_focus && !mini_controls);
  370. mSkipBackCtrl->setEnabled(has_focus && !mini_controls);
  372. mVolumeCtrl->setVisible(has_focus);
  373. mVolumeCtrl->setEnabled(has_focus);
  374. mVolumeSliderCtrl->setEnabled(has_focus && shouldVolumeSliderBeVisible());
  375. mVolumeSliderCtrl->setVisible(has_focus && shouldVolumeSliderBeVisible());
  377. mWhitelistIcon->setVisible(false);
  378. mSecureLockIcon->setVisible(false);
  379. if (mMediaPanelScroll)
  380. {
  381. mMediaPanelScroll->setVisible(false);
  382. mScrollUpCtrl->setVisible(false);
  383. mScrollDownCtrl->setVisible(false);
  384. mScrollRightCtrl->setVisible(false);
  385. mScrollDownCtrl->setVisible(false);
  386. }
  388. F32 volume = media_impl->getVolume();
  389. // movie's url changed
  390. if(mCurrentURL!=mPreviousURL)
  391. {
  392. mMovieDuration = media_plugin->getDuration();
  393. mPreviousURL = mCurrentURL;
  394. }
  396. if(mMovieDuration == 0) 
  397. {
  398. mMovieDuration = media_plugin->getDuration();
  399. mMediaPlaySliderCtrl->setValue(0);
  400. mMediaPlaySliderCtrl->setEnabled(false);
  401. }
  402. // TODO: What if it's not fully loaded
  404. if(mUpdateSlider && mMovieDuration!= 0)
  405. {
  406. F64 current_time =  media_plugin->getCurrentTime();
  407. F32 percent = current_time / mMovieDuration;
  408. mMediaPlaySliderCtrl->setValue(percent);
  409. mMediaPlaySliderCtrl->setEnabled(true);
  410. }
  412. // video vloume
  413. if(volume <= 0.0)
  414. {
  415. mMuteBtn->setToggleState(true);
  416. }
  417. else if (volume >= 1.0)
  418. {
  419. mMuteBtn->setToggleState(false);
  420. }
  421. else
  422. {
  423. mMuteBtn->setToggleState(false);
  424. }
  426. switch(result)
  427. {
  428. case LLPluginClassMediaOwner::MEDIA_PLAYING:
  429. mPlayCtrl->setEnabled(FALSE);
  430. mPlayCtrl->setVisible(FALSE);
  431. mPauseCtrl->setEnabled(TRUE);
  432. mPauseCtrl->setVisible(has_focus);
  434. break;
  435. case LLPluginClassMediaOwner::MEDIA_PAUSED:
  436. default:
  437. mPauseCtrl->setEnabled(FALSE);
  438. mPauseCtrl->setVisible(FALSE);
  439. mPlayCtrl->setEnabled(TRUE);
  440. mPlayCtrl->setVisible(has_focus);
  441. break;
  442. }
  443. }
  444. else   // web based
  445. {
  446. if(media_plugin)
  447. {
  448. mCurrentURL = media_plugin->getLocation();
  449. }
  450. else
  451. {
  452. mCurrentURL.clear();
  453. }
  455. mPlayCtrl->setVisible(FALSE);
  456. mPauseCtrl->setVisible(FALSE);
  457. mMediaStopCtrl->setVisible(FALSE);
  458. mMediaAddressCtrl->setVisible(has_focus && !mini_controls);
  459. mMediaAddressCtrl->setEnabled(has_focus && !mini_controls);
  460. mMediaPlaySliderPanel->setVisible(FALSE);
  461. mMediaPlaySliderPanel->setEnabled(FALSE);
  462. mSkipFwdCtrl->setVisible(FALSE);
  463. mSkipFwdCtrl->setEnabled(FALSE);
  464. mSkipBackCtrl->setVisible(FALSE);
  465. mSkipBackCtrl->setEnabled(FALSE);
  467. mVolumeCtrl->setVisible(FALSE);
  468. mVolumeSliderCtrl->setVisible(FALSE);
  469. mVolumeCtrl->setEnabled(FALSE);
  470. mVolumeSliderCtrl->setEnabled(FALSE);
  472. if (mMediaPanelScroll)
  473. {
  474. mMediaPanelScroll->setVisible(has_focus);
  475. mScrollUpCtrl->setVisible(has_focus);
  476. mScrollDownCtrl->setVisible(has_focus);
  477. mScrollRightCtrl->setVisible(has_focus);
  478. mScrollDownCtrl->setVisible(has_focus);
  479. }
  480. // TODO: get the secure lock bool from media plug in
  481. std::string prefix =  std::string("https://");
  482. std::string test_prefix = mCurrentURL.substr(0, prefix.length());
  483. LLStringUtil::toLower(test_prefix);
  484. if(test_prefix == prefix)
  485. {
  486. mSecureLockIcon->setVisible(has_focus);
  487. }
  489. if(mCurrentURL!=mPreviousURL)
  490. {
  491. setCurrentURL();
  492. mPreviousURL = mCurrentURL;
  493. }
  495. if(result == LLPluginClassMediaOwner::MEDIA_LOADING)
  496. {
  497. mReloadCtrl->setEnabled(FALSE);
  498. mReloadCtrl->setVisible(FALSE);
  499. mStopCtrl->setEnabled(TRUE);
  500. mStopCtrl->setVisible(has_focus);
  501. }
  502. else
  503. {
  504. mReloadCtrl->setEnabled(TRUE);
  505. mReloadCtrl->setVisible(has_focus);
  506. mStopCtrl->setEnabled(FALSE);
  507. mStopCtrl->setVisible(FALSE);
  508. }
  509. }
  512. if(media_plugin)
  513. {
  514. //
  515. // Handle progress bar
  516. //
  517. if(LLPluginClassMediaOwner::MEDIA_LOADING == media_plugin->getStatus())
  518. {
  519. mMediaProgressPanel->setVisible(true);
  520. mMediaProgressBar->setPercent(media_plugin->getProgressPercent());
  521. }
  522. else
  523. {
  524. mMediaProgressPanel->setVisible(false);
  525. }
  526. }
  528. if(media_impl)
  529. {
  530. //
  531. // Handle Scrolling
  532. //
  533. switch (mScrollState) 
  534. {
  535. case SCROLL_UP:
  536. media_impl->scrollWheel(0, -1, MASK_NONE);
  537. break;
  538. case SCROLL_DOWN:
  539. media_impl->scrollWheel(0, 1, MASK_NONE);
  540. break;
  541. case SCROLL_LEFT:
  542. media_impl->scrollWheel(1, 0, MASK_NONE);
  543. // media_impl->handleKeyHere(KEY_LEFT, MASK_NONE);
  544. break;
  545. case SCROLL_RIGHT:
  546. media_impl->scrollWheel(-1, 0, MASK_NONE);
  547. // media_impl->handleKeyHere(KEY_RIGHT, MASK_NONE);
  548. break;
  549. case SCROLL_NONE:
  550. default:
  551. break;
  552. }
  553. }
  555. setVisible(enabled);
  557. //
  558. // Calculate position and shape of the controls
  559. //
  560. std::vector<LLVector3>::iterator vert_it;
  561. std::vector<LLVector3>::iterator vert_end;
  562. std::vector<LLVector3> vect_face;
  564. LLVolume* volume = objectp->getVolume();
  566. if (volume)
  567. {
  568. const LLVolumeFace& vf = volume->getVolumeFace(mTargetObjectFace);
  570. const LLVector3* ext = vf.mExtents;
  572. LLVector3 center = (ext[0]+ext[1])*0.5f;
  573. LLVector3 size = (ext[1]-ext[0])*0.5f;
  574. LLVector3 vert[] =
  575. {
  576. center + size.scaledVec(LLVector3(1,1,1)),
  577. center + size.scaledVec(LLVector3(-1,1,1)),
  578. center + size.scaledVec(LLVector3(1,-1,1)),
  579. center + size.scaledVec(LLVector3(-1,-1,1)),
  580. center + size.scaledVec(LLVector3(1,1,-1)),
  581. center + size.scaledVec(LLVector3(-1,1,-1)),
  582. center + size.scaledVec(LLVector3(1,-1,-1)),
  583. center + size.scaledVec(LLVector3(-1,-1,-1)),
  584. };
  586. LLVOVolume* vo = (LLVOVolume*) objectp;
  588. for (U32 i = 0; i < 8; i++)
  589. {
  590. vect_face.push_back(vo->volumePositionToAgent(vert[i]));
  591. }
  592. }
  593. vert_it = vect_face.begin();
  594. vert_end = vect_face.end();
  596. glh::matrix4f mat;
  597. if (!is_hud) 
  598. {
  599. mat = glh_get_current_projection() * glh_get_current_modelview();
  600. }
  601. else {
  602. glh::matrix4f proj, modelview;
  603. if (get_hud_matrices(proj, modelview))
  604. mat = proj * modelview;
  605. }
  606. LLVector3 min = LLVector3(1,1,1);
  607. LLVector3 max = LLVector3(-1,-1,-1);
  608. for(; vert_it != vert_end; ++vert_it)
  609. {
  610. // project silhouette vertices into screen space
  611. glh::vec3f screen_vert = glh::vec3f(vert_it->mV); 
  612. mat.mult_matrix_vec(screen_vert);
  614. // add to screenspace bounding box
  615. update_min_max(min, max, LLVector3(screen_vert.v));
  616. }
  618. // convert screenspace bbox to pixels (in screen coords)
  619. LLRect window_rect = gViewerWindow->getWorldViewRectScaled();
  620. LLCoordGL screen_min;
  621. screen_min.mX = llround((F32)window_rect.getWidth() * (min.mV[VX] + 1.f) * 0.5f);
  622. screen_min.mY = llround((F32)window_rect.getHeight() * (min.mV[VY] + 1.f) * 0.5f);
  624. LLCoordGL screen_max;
  625. screen_max.mX = llround((F32)window_rect.getWidth() * (max.mV[VX] + 1.f) * 0.5f);
  626. screen_max.mY = llround((F32)window_rect.getHeight() * (max.mV[VY] + 1.f) * 0.5f);
  628. // grow panel so that screenspace bounding box fits inside "media_region" element of panel
  629. LLRect media_panel_rect;
  630. // Get the height of the controls (less the volume slider)
  631. S32 controls_height = mMediaControlsStack->getRect().getHeight() - mVolumeSliderCtrl->getRect().getHeight();
  632. getParent()->screenRectToLocal(LLRect(screen_min.mX, screen_max.mY, screen_max.mX, screen_min.mY), &media_panel_rect);
  633. media_panel_rect.mTop += controls_height;
  635. // keep all parts of panel on-screen
  636. // Area of the top of the world view to avoid putting the controls
  637. window_rect.mTop -= mTopWorldViewAvoidZone;
  638. // Don't include "spacing" bookends on left & right of the media controls
  639. window_rect.mLeft -= mLeftBookend->getRect().getWidth();
  640. window_rect.mRight += mRightBookend->getRect().getWidth();
  641. // Don't include the volume slider
  642. window_rect.mBottom -= mVolumeSliderCtrl->getRect().getHeight();
  643. media_panel_rect.intersectWith(window_rect);
  645. // clamp to minimum size, keeping rect inside window
  646. S32 centerX = media_panel_rect.getCenterX();
  647. S32 centerY = media_panel_rect.getCenterY();
  648. // Shrink screen rect by min width and height, to ensure containment
  649. window_rect.stretch(-mMinWidth/2, -mMinHeight/2);
  650. window_rect.clampPointToRect(centerX, centerY);
  651. media_panel_rect.setCenterAndSize(centerX, centerY, 
  652.   llmax(mMinWidth, media_panel_rect.getWidth()),
  653.   llmax(mMinHeight, media_panel_rect.getHeight()));
  655. // Finally set the size of the panel
  656. setShape(media_panel_rect, true);
  658. // Test mouse position to see if the cursor is stationary
  659. LLCoordWindow cursor_pos_window;
  660. getWindow()->getCursorPosition(&cursor_pos_window);
  662. // If last pos is not equal to current pos, the mouse has moved
  663. // We need to reset the timer, and make sure the panel is visible
  664. if(cursor_pos_window.mX != mLastCursorPos.mX ||
  665.    cursor_pos_window.mY != mLastCursorPos.mY ||
  666.    mScrollState != SCROLL_NONE)
  667. {
  668. mInactivityTimer.start();
  669. mLastCursorPos = cursor_pos_window;
  670. }
  672. if(isMouseOver() || hasFocus())
  673. {
  674. // Never fade the controls if the mouse is over them or they have keyboard focus.
  675. mFadeTimer.stop();
  676. }
  677. else if(!mClearFaceOnFade && (mInactivityTimer.getElapsedTimeF32() < mInactiveTimeout))
  678. {
  679. // Mouse is over the object, but has not been stationary for long enough to fade the UI
  680. mFadeTimer.stop();
  681. }
  682. else if(! mFadeTimer.getStarted() )
  683. {
  684. // we need to start fading the UI (and we have not already started)
  685. mFadeTimer.reset();
  686. mFadeTimer.start();
  687. }
  688. else
  689. {
  690. // I don't think this is correct anymore.  This is done in draw() after the fade has completed.
  691. // setVisible(FALSE);
  692. }
  693. }
  694. }
  696. /*virtual*/
  697. void LLPanelPrimMediaControls::draw()
  698. {
  699. F32 alpha = getDrawContext().mAlpha;
  700. if(mFadeTimer.getStarted())
  701. {
  702. F32 time = mFadeTimer.getElapsedTimeF32();
  703. alpha *= llmax(lerp(1.0, 0.0, time / mControlFadeTime), 0.0f);
  705. if(time >= mControlFadeTime)
  706. {
  707. if(mClearFaceOnFade)
  708. {
  709. // Hiding this object makes scroll events go missing after it fades out 
  710. // (see DEV-41755 for a full description of the train wreck).
  711. // Only hide the controls when we're untargeting.
  712. setVisible(FALSE);
  714. mClearFaceOnFade = false;
  715. mVolumeSliderVisible = 0;
  716. mTargetImplID = LLUUID::null;
  717. mTargetObjectID = LLUUID::null;
  718. mTargetObjectFace = 0;
  719. }
  720. }
  721. }
  723. // Build rect for icon area in coord system of this panel
  724. // Assumes layout_stack is a direct child of this panel
  725. mMediaControlsStack->updateLayout();
  727. // adjust for layout stack spacing
  728. S32 space = mMediaControlsStack->getPanelSpacing() + 2;
  729. LLRect controls_bg_area = mMediaControlsStack->getRect();
  731. controls_bg_area.mTop += space + 2;
  733. // adjust to ignore space from volume slider
  734. controls_bg_area.mBottom += mVolumeSliderCtrl->getRect().getHeight();
  736. // adjust to ignore space from left bookend padding
  737. controls_bg_area.mLeft += mLeftBookend->getRect().getWidth() - space;
  739. // ignore space from right bookend padding
  740. controls_bg_area.mRight -= mRightBookend->getRect().getWidth() - space - 2;
  742. // draw control background UI image
  743. mBackgroundImage->draw( controls_bg_area, UI_VERTEX_COLOR % alpha);
  745. // draw volume slider background UI image
  746. if (mVolumeSliderCtrl->getVisible())
  747. {
  748. LLRect volume_slider_rect;
  749. screenRectToLocal(mVolumeSliderCtrl->calcScreenRect(), &volume_slider_rect);
  750. mVolumeSliderBackgroundImage->draw(volume_slider_rect, UI_VERTEX_COLOR % alpha);
  751. }
  753. {
  754. LLViewDrawContext context(alpha);
  755. LLPanel::draw();
  756. }
  757. }
  759. BOOL LLPanelPrimMediaControls::handleScrollWheel(S32 x, S32 y, S32 clicks)
  760. {
  761. mInactivityTimer.start();
  762. return LLViewerMediaFocus::getInstance()->handleScrollWheel(x, y, clicks);
  763. }
  765. BOOL LLPanelPrimMediaControls::handleMouseDown(S32 x, S32 y, MASK mask)
  766. {
  767. mInactivityTimer.start();
  768. return LLPanel::handleMouseDown(x, y, mask);
  769. }
  771. BOOL LLPanelPrimMediaControls::handleMouseUp(S32 x, S32 y, MASK mask)
  772. {
  773. mInactivityTimer.start();
  774. return LLPanel::handleMouseUp(x, y, mask);
  775. }
  777. BOOL LLPanelPrimMediaControls::handleKeyHere( KEY key, MASK mask )
  778. {
  779. mInactivityTimer.start();
  780. return LLPanel::handleKeyHere(key, mask);
  781. }
  783. bool LLPanelPrimMediaControls::isMouseOver()
  784. {
  785. bool result = false;
  787. if( getVisible() )
  788. {
  789. LLCoordWindow cursor_pos_window;
  790. LLCoordScreen cursor_pos_screen;
  791. LLCoordGL cursor_pos_gl;
  792. S32 x, y;
  793. getWindow()->getCursorPosition(&cursor_pos_window);
  794. getWindow()->convertCoords(cursor_pos_window, &cursor_pos_gl);
  796. if(mMediaControlsStack->getVisible())
  797. {
  798. mMediaControlsStack->screenPointToLocal(cursor_pos_gl.mX, cursor_pos_gl.mY, &x, &y);
  800. LLView *hit_child = mMediaControlsStack->childFromPoint(x, y);
  801. if(hit_child && hit_child->getVisible())
  802. {
  803. // This was useful for debugging both coordinate translation and view hieararchy problems...
  804. // llinfos << "mouse coords: " << x << ", " << y << " hit child " << hit_child->getName() << llendl;
  806. // This will be a direct child of the LLLayoutStack, which should be a layout_panel.
  807. // These may not shown/hidden by the logic in updateShape(), so we need to do another hit test on the children of the layout panel,
  808. // which are the actual controls.
  809. hit_child->screenPointToLocal(cursor_pos_gl.mX, cursor_pos_gl.mY, &x, &y);
  811. LLView *hit_child_2 = hit_child->childFromPoint(x, y);
  812. if(hit_child_2 && hit_child_2->getVisible())
  813. {
  814. // This was useful for debugging both coordinate translation and view hieararchy problems...
  815. // llinfos << "    mouse coords: " << x << ", " << y << " hit child 2 " << hit_child_2->getName() << llendl;
  816. result = true;
  817. }
  818. }
  819. }
  820. }
  822. return result;
  823. }
  826. void LLPanelPrimMediaControls::onClickClose()
  827. {
  828. close();
  829. }
  831. void LLPanelPrimMediaControls::close()
  832. {
  833. resetZoomLevel(true);
  834. LLViewerMediaFocus::getInstance()->clearFocus();
  835. setVisible(FALSE);
  836. }
  839. void LLPanelPrimMediaControls::onClickBack()
  840. {
  841. focusOnTarget();
  843. LLViewerMediaImpl* impl =getTargetMediaImpl();
  845. if (impl)
  846. {
  847. impl->navigateBack();
  848. }
  849. }
  851. void LLPanelPrimMediaControls::onClickForward()
  852. {
  853. focusOnTarget();
  855. LLViewerMediaImpl* impl = getTargetMediaImpl();
  857. if (impl)
  858. {
  859. impl->navigateForward();
  860. }
  861. }
  863. void LLPanelPrimMediaControls::onClickHome()
  864. {
  865. focusOnTarget();
  867. LLViewerMediaImpl* impl = getTargetMediaImpl();
  869. if(impl)
  870. {
  871. impl->navigateHome();
  872. }
  873. }
  875. void LLPanelPrimMediaControls::onClickOpen()
  876. {
  877. LLViewerMediaImpl* impl = getTargetMediaImpl();
  878. if(impl)
  879. {
  880. LLWeb::loadURL(impl->getCurrentMediaURL());
  881. }
  882. }
  884. void LLPanelPrimMediaControls::onClickReload()
  885. {
  886. focusOnTarget();
  888. //LLViewerMedia::navigateHome();
  889. LLViewerMediaImpl* impl = getTargetMediaImpl();
  891. if(impl)
  892. {
  893. impl->navigateReload();
  894. }
  895. }
  897. void LLPanelPrimMediaControls::onClickPlay()
  898. {
  899. focusOnTarget();
  901. LLViewerMediaImpl* impl = getTargetMediaImpl();
  903. if(impl)
  904. {
  905. impl->play();
  906. }
  907. }
  909. void LLPanelPrimMediaControls::onClickPause()
  910. {
  911. focusOnTarget();
  913. LLViewerMediaImpl* impl = getTargetMediaImpl();
  915. if(impl)
  916. {
  917. impl->pause();
  918. }
  919. }
  921. void LLPanelPrimMediaControls::onClickStop()
  922. {
  923. focusOnTarget();
  925. LLViewerMediaImpl* impl = getTargetMediaImpl();
  927. if(impl)
  928. {
  929. impl->navigateStop();
  930. }
  931. }
  933. void LLPanelPrimMediaControls::onClickMediaStop()
  934. {
  935. focusOnTarget();
  937. LLViewerMediaImpl* impl = getTargetMediaImpl();
  939. if(impl)
  940. {
  941. impl->stop();
  942. }
  943. }
  945. void LLPanelPrimMediaControls::onClickSkipBack()
  946. {
  947. focusOnTarget();
  949. LLViewerMediaImpl* impl =getTargetMediaImpl();
  951. if (impl)
  952. {
  953. impl->skipBack(mSkipStep);
  954. }
  955. }
  957. void LLPanelPrimMediaControls::onClickSkipForward()
  958. {
  959. focusOnTarget();
  961. LLViewerMediaImpl* impl = getTargetMediaImpl();
  963. if (impl)
  964. {
  965. impl->skipForward(mSkipStep);
  966. }
  967. }
  969. void LLPanelPrimMediaControls::onClickZoom()
  970. {
  971. focusOnTarget();
  973. if(mCurrentZoom == ZOOM_NONE)
  974. {
  975. nextZoomLevel();
  976. }
  977. }
  979. void LLPanelPrimMediaControls::nextZoomLevel()
  980. {
  981. int index = 0;
  982. while (index < kNumZoomLevels)
  983. {
  984. if (kZoomLevels[index] == mCurrentZoom) 
  985. {
  986. index++;
  987. break;
  988. }
  989. index++;
  990. }
  991. mCurrentZoom = kZoomLevels[index % kNumZoomLevels];
  992. updateZoom();
  993. }
  995. void LLPanelPrimMediaControls::resetZoomLevel(bool reset_camera)
  996. {
  997. if(mCurrentZoom != ZOOM_NONE)
  998. {
  999. mCurrentZoom = ZOOM_NONE;
  1000. if(reset_camera)
  1001. {
  1002. updateZoom();
  1003. }
  1004. }
  1005. }
  1007. void LLPanelPrimMediaControls::updateZoom()
  1008. {
  1009. F32 zoom_padding = 0.0f;
  1010. switch (mCurrentZoom)
  1011. {
  1012. case ZOOM_NONE:
  1013. {
  1014. gAgent.setFocusOnAvatar(TRUE, ANIMATE);
  1015. break;
  1016. }
  1017. case ZOOM_FAR:
  1018. {
  1019. zoom_padding = mZoomFarPadding;
  1020. break;
  1021. }
  1022. case ZOOM_MEDIUM:
  1023. {
  1024. zoom_padding = mZoomMediumPadding;
  1025. break;
  1026. }
  1027. case ZOOM_NEAR:
  1028. {
  1029. zoom_padding = mZoomNearPadding;
  1030. break;
  1031. }
  1032. default:
  1033. {
  1034. gAgent.setFocusOnAvatar(TRUE, ANIMATE);
  1035. break;
  1036. }
  1037. }
  1039. if (zoom_padding > 0.0f)
  1040. {
  1041. // since we only zoom into medium for now, always set zoom_in constraint to true
  1042. LLViewerMediaFocus::setCameraZoom(getTargetObject(), mTargetObjectNormal, zoom_padding, true);
  1043. }
  1045. // Remember the object ID/face we zoomed into, so we can update the zoom icon appropriately
  1046. mZoomObjectID = mTargetObjectID;
  1047. mZoomObjectFace = mTargetObjectFace;
  1048. }
  1050. void LLPanelPrimMediaControls::onScrollUp(void* user_data)
  1051. {
  1052. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1053. this_panel->focusOnTarget();
  1055. LLViewerMediaImpl* impl = this_panel->getTargetMediaImpl();
  1057. if(impl)
  1058. {
  1059. impl->scrollWheel(0, -1, MASK_NONE);
  1060. }
  1061. }
  1062. void LLPanelPrimMediaControls::onScrollUpHeld(void* user_data)
  1063. {
  1064. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1065. this_panel->mScrollState = SCROLL_UP;
  1066. }
  1067. void LLPanelPrimMediaControls::onScrollRight(void* user_data)
  1068. {
  1069. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1070. this_panel->focusOnTarget();
  1072. LLViewerMediaImpl* impl = this_panel->getTargetMediaImpl();
  1074. if(impl)
  1075. {
  1076. impl->scrollWheel(-1, 0, MASK_NONE);
  1077. // impl->handleKeyHere(KEY_RIGHT, MASK_NONE);
  1078. }
  1079. }
  1080. void LLPanelPrimMediaControls::onScrollRightHeld(void* user_data)
  1081. {
  1082. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1083. this_panel->mScrollState = SCROLL_RIGHT;
  1084. }
  1086. void LLPanelPrimMediaControls::onScrollLeft(void* user_data)
  1087. {
  1088. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1089. this_panel->focusOnTarget();
  1091. LLViewerMediaImpl* impl = this_panel->getTargetMediaImpl();
  1093. if(impl)
  1094. {
  1095. impl->scrollWheel(1, 0, MASK_NONE);
  1096. // impl->handleKeyHere(KEY_LEFT, MASK_NONE);
  1097. }
  1098. }
  1099. void LLPanelPrimMediaControls::onScrollLeftHeld(void* user_data)
  1100. {
  1101. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1102. this_panel->mScrollState = SCROLL_LEFT;
  1103. }
  1105. void LLPanelPrimMediaControls::onScrollDown(void* user_data)
  1106. {
  1107. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1108. this_panel->focusOnTarget();
  1110. LLViewerMediaImpl* impl = this_panel->getTargetMediaImpl();
  1112. if(impl)
  1113. {
  1114. impl->scrollWheel(0, 1, MASK_NONE);
  1115. }
  1116. }
  1117. void LLPanelPrimMediaControls::onScrollDownHeld(void* user_data)
  1118. {
  1119. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1120. this_panel->mScrollState = SCROLL_DOWN;
  1121. }
  1123. void LLPanelPrimMediaControls::onScrollStop(void* user_data)
  1124. {
  1125. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (user_data);
  1126. this_panel->mScrollState = SCROLL_NONE;
  1127. }
  1129. void LLPanelPrimMediaControls::onCommitURL()
  1130. {
  1131. focusOnTarget();
  1133. std::string url = mMediaAddress->getValue().asString();
  1134. if(getTargetMediaImpl() && !url.empty())
  1135. {
  1136. getTargetMediaImpl()->navigateTo( url, "", true);
  1138. // Make sure keyboard focus is set to the media focus object.
  1139. gFocusMgr.setKeyboardFocus(LLViewerMediaFocus::getInstance());
  1141. }
  1142. mPauseFadeout = false;
  1143. mFadeTimer.start();
  1144. }
  1147. void LLPanelPrimMediaControls::onInputURL(LLFocusableElement* caller, void *userdata)
  1148. {
  1150. LLPanelPrimMediaControls* this_panel = static_cast<LLPanelPrimMediaControls*> (userdata);
  1151. this_panel->focusOnTarget();
  1153. this_panel->mPauseFadeout = true;
  1154. this_panel->mFadeTimer.stop();
  1155. this_panel->mFadeTimer.reset();
  1157. }
  1159. void LLPanelPrimMediaControls::setCurrentURL()
  1160. {
  1161. #ifdef USE_COMBO_BOX_FOR_MEDIA_URL
  1162. // LLComboBox* media_address_combo = getChild<LLComboBox>("media_address_combo");
  1163. // // redirects will navigate momentarily to about:blank, don't add to history
  1164. // if (media_address_combo && mCurrentURL != "about:blank")
  1165. // {
  1166. // media_address_combo->remove(mCurrentURL);
  1167. // media_address_combo->add(mCurrentURL, ADD_SORTED);
  1168. // media_address_combo->selectByValue(mCurrentURL);
  1169. // }
  1170. #else   // USE_COMBO_BOX_FOR_MEDIA_URL
  1171. if (mMediaAddress && mCurrentURL != "about:blank")
  1172. {
  1173. mMediaAddress->setValue(mCurrentURL);
  1174. }
  1175. #endif // USE_COMBO_BOX_FOR_MEDIA_URL
  1176. }
  1178. void LLPanelPrimMediaControls::onCommitSlider()
  1179. {
  1180. focusOnTarget();
  1182. LLViewerMediaImpl* media_impl = getTargetMediaImpl();
  1183. if (media_impl) 
  1184. {
  1185. // get slider value
  1186. F64 slider_value = mMediaPlaySliderCtrl->getValue().asReal();
  1187. if(slider_value <= 0.0)
  1188. {
  1189. media_impl->stop();
  1190. }
  1191. else 
  1192. {
  1193. media_impl->seek(slider_value*mMovieDuration);
  1194. //mUpdateSlider= false;
  1195. }
  1196. }
  1197. }
  1199. void LLPanelPrimMediaControls::onCommitVolumeUp()
  1200. {
  1201. focusOnTarget();
  1203. LLViewerMediaImpl* media_impl = getTargetMediaImpl();
  1204. if (media_impl) 
  1205. {
  1206. F32 volume = media_impl->getVolume();
  1208. volume += 0.1f;
  1209. if(volume >= 1.0f)
  1210. {
  1211. volume = 1.0f;
  1212. }
  1214. media_impl->setVolume(volume);
  1215. mMuteBtn->setToggleState(false);
  1216. }
  1217. }
  1219. void LLPanelPrimMediaControls::onCommitVolumeDown()
  1220. {
  1221. focusOnTarget();
  1223. LLViewerMediaImpl* media_impl = getTargetMediaImpl();
  1224. if (media_impl) 
  1225. {
  1226. F32 volume = media_impl->getVolume();
  1228. volume -= 0.1f;
  1229. if(volume <= 0.0f)
  1230. {
  1231. volume = 0.0f;
  1232. }
  1234. media_impl->setVolume(volume);
  1235. mMuteBtn->setToggleState(false);
  1236. }
  1237. }
  1239. void LLPanelPrimMediaControls::onCommitVolumeSlider()
  1240. {
  1241. focusOnTarget();
  1243. LLViewerMediaImpl* media_impl = getTargetMediaImpl();
  1244. if (media_impl) 
  1245. {
  1246. media_impl->setVolume(mVolumeSliderCtrl->getValueF32());
  1247. }
  1248. }
  1250. void LLPanelPrimMediaControls::onToggleMute()
  1251. {
  1252. focusOnTarget();
  1254. LLViewerMediaImpl* media_impl = getTargetMediaImpl();
  1255. if (media_impl) 
  1256. {
  1257. F32 volume = media_impl->getVolume();
  1259. if(volume > 0.0)
  1260. {
  1261. media_impl->setVolume(0.0);
  1262. }
  1263. else if (mVolumeSliderCtrl->getValueF32() == 0.0)
  1264. {
  1265. media_impl->setVolume(1.0);
  1266. mVolumeSliderCtrl->setValue(1.0);
  1267. }
  1268. else 
  1269. {
  1270. media_impl->setVolume(mVolumeSliderCtrl->getValueF32());
  1271. }
  1272. }
  1273. }
  1275. void LLPanelPrimMediaControls::showVolumeSlider()
  1276. {
  1277. mVolumeSliderVisible++;
  1278. }
  1280. void LLPanelPrimMediaControls::hideVolumeSlider()
  1281. {
  1282. mVolumeSliderVisible--;
  1283. }
  1285. bool LLPanelPrimMediaControls::shouldVolumeSliderBeVisible()
  1286. {
  1287. return mVolumeSliderVisible > 0;
  1288. }