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

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

游戏引擎

开发平台：

C++ Builder

llfloatertools.cpp：源码内容
  1. /** 
  2.  * @file llfloatertools.cpp
  3.  * @brief The edit tools, including move, position, land, etc.
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llfloatertools.h"
  37. #include "llfontgl.h"
  38. #include "llcoord.h"
  39. //#include "llgl.h"
  41. #include "llagent.h"
  42. #include "llbutton.h"
  43. #include "llcheckboxctrl.h"
  44. #include "llcombobox.h"
  45. #include "lldraghandle.h"
  46. #include "llerror.h"
  47. #include "llfloaterbuildoptions.h"
  48. #include "llfloatermediasettings.h"
  49. #include "llfloateropenobject.h"
  50. #include "llfloaterreg.h"
  51. #include "llfocusmgr.h"
  52. #include "llmediaentry.h"
  53. #include "llmediactrl.h"
  54. #include "llmenugl.h"
  55. #include "llnotificationsutil.h"
  56. #include "llpanelcontents.h"
  57. #include "llpanelface.h"
  58. #include "llpanelland.h"
  59. #include "llpanelobjectinventory.h"
  60. #include "llpanelobject.h"
  61. #include "llpanelvolume.h"
  62. #include "llpanelpermissions.h"
  63. #include "llradiogroup.h"
  64. #include "llresmgr.h"
  65. #include "llselectmgr.h"
  66. #include "llslider.h"
  67. #include "llstatusbar.h"
  68. #include "lltabcontainer.h"
  69. #include "lltextbox.h"
  70. #include "lltoolbrush.h"
  71. #include "lltoolcomp.h"
  72. #include "lltooldraganddrop.h"
  73. #include "lltoolface.h"
  74. #include "lltoolfocus.h"
  75. #include "lltoolgrab.h"
  76. #include "lltoolgrab.h"
  77. #include "lltoolindividual.h"
  78. #include "lltoolmgr.h"
  79. #include "lltoolpie.h"
  80. #include "lltoolpipette.h"
  81. #include "lltoolplacer.h"
  82. #include "lltoolselectland.h"
  83. #include "lltrans.h"
  84. #include "llui.h"
  85. #include "llviewercontrol.h"
  86. #include "llviewerjoystick.h"
  87. #include "llviewerregion.h"
  88. #include "llviewermenu.h"
  89. #include "llviewerparcelmgr.h"
  90. #include "llviewerwindow.h"
  91. #include "llvovolume.h"
  92. #include "lluictrlfactory.h"
  94. // Globals
  95. LLFloaterTools *gFloaterTools = NULL;
  96. bool LLFloaterTools::sShowObjectCost = true;
  98. const std::string PANEL_NAMES[LLFloaterTools::PANEL_COUNT] =
  99. {
  100. std::string("General"),  // PANEL_GENERAL,
  101. std::string("Object"),  // PANEL_OBJECT,
  102. std::string("Features"), // PANEL_FEATURES,
  103. std::string("Texture"), // PANEL_FACE,
  104. std::string("Content"), // PANEL_CONTENTS,
  105. };
  107. // Local prototypes
  108. void commit_select_component(void *data);
  109. void click_show_more(void*);
  110. void click_popup_info(void*);
  111. void click_popup_done(void*);
  112. void click_popup_minimize(void*);
  113. void click_popup_rotate_left(void*);
  114. void click_popup_rotate_reset(void*);
  115. void click_popup_rotate_right(void*);
  116. void commit_slider_dozer_force(LLUICtrl *);
  117. void click_apply_to_selection(void*);
  118. void commit_radio_group_focus(LLUICtrl* ctrl);
  119. void commit_radio_group_move(LLUICtrl* ctrl);
  120. void commit_radio_group_edit(LLUICtrl* ctrl);
  121. void commit_radio_group_land(LLUICtrl* ctrl);
  122. void commit_grid_mode(LLUICtrl *);
  123. void commit_slider_zoom(LLUICtrl *ctrl);
  126. //static
  127. void* LLFloaterTools::createPanelPermissions(void* data)
  128. {
  129. LLFloaterTools* floater = (LLFloaterTools*)data;
  130. floater->mPanelPermissions = new LLPanelPermissions();
  131. return floater->mPanelPermissions;
  132. }
  133. //static
  134. void* LLFloaterTools::createPanelObject(void* data)
  135. {
  136. LLFloaterTools* floater = (LLFloaterTools*)data;
  137. floater->mPanelObject = new LLPanelObject();
  138. return floater->mPanelObject;
  139. }
  141. //static
  142. void* LLFloaterTools::createPanelVolume(void* data)
  143. {
  144. LLFloaterTools* floater = (LLFloaterTools*)data;
  145. floater->mPanelVolume = new LLPanelVolume();
  146. return floater->mPanelVolume;
  147. }
  149. //static
  150. void* LLFloaterTools::createPanelFace(void* data)
  151. {
  152. LLFloaterTools* floater = (LLFloaterTools*)data;
  153. floater->mPanelFace = new LLPanelFace();
  154. return floater->mPanelFace;
  155. }
  157. //static
  158. void* LLFloaterTools::createPanelContents(void* data)
  159. {
  160. LLFloaterTools* floater = (LLFloaterTools*)data;
  161. floater->mPanelContents = new LLPanelContents();
  162. return floater->mPanelContents;
  163. }
  165. //static
  166. void* LLFloaterTools::createPanelLandInfo(void* data)
  167. {
  168. LLFloaterTools* floater = (LLFloaterTools*)data;
  169. floater->mPanelLandInfo = new LLPanelLandInfo();
  170. return floater->mPanelLandInfo;
  171. }
  173. static const std::string toolNames[]={
  174. "ToolCube",
  175. "ToolPrism",
  176. "ToolPyramid",
  177. "ToolTetrahedron",
  178. "ToolCylinder",
  179. "ToolHemiCylinder",
  180. "ToolCone",
  181. "ToolHemiCone",
  182. "ToolSphere",
  183. "ToolHemiSphere",
  184. "ToolTorus",
  185. "ToolTube",
  186. "ToolRing",
  187. "ToolTree",
  188. "ToolGrass"};
  189. LLPCode toolData[]={
  190. LL_PCODE_CUBE,
  191. LL_PCODE_PRISM,
  192. LL_PCODE_PYRAMID,
  193. LL_PCODE_TETRAHEDRON,
  194. LL_PCODE_CYLINDER,
  195. LL_PCODE_CYLINDER_HEMI,
  196. LL_PCODE_CONE,
  197. LL_PCODE_CONE_HEMI,
  198. LL_PCODE_SPHERE,
  199. LL_PCODE_SPHERE_HEMI,
  200. LL_PCODE_TORUS,
  201. LLViewerObject::LL_VO_SQUARE_TORUS,
  202. LLViewerObject::LL_VO_TRIANGLE_TORUS,
  203. LL_PCODE_LEGACY_TREE,
  204. LL_PCODE_LEGACY_GRASS};
  206. BOOL LLFloaterTools::postBuild()
  207. {
  208. // Hide until tool selected
  209. setVisible(FALSE);
  211. // Since we constantly show and hide this during drags, don't
  212. // make sounds on visibility changes.
  213. setSoundFlags(LLView::SILENT);
  215. getDragHandle()->setEnabled( !gSavedSettings.getBOOL("ToolboxAutoMove") );
  217. LLRect rect;
  218. mBtnFocus = getChild<LLButton>("button focus");//btn;
  219. mBtnMove = getChild<LLButton>("button move");
  220. mBtnEdit = getChild<LLButton>("button edit");
  221. mBtnCreate = getChild<LLButton>("button create");
  222. mBtnLand = getChild<LLButton>("button land" );
  223. mTextStatus = getChild<LLTextBox>("text status");
  224. mRadioGroupFocus = getChild<LLRadioGroup>("focus_radio_group");
  225. mRadioGroupMove = getChild<LLRadioGroup>("move_radio_group");
  226. mRadioGroupEdit = getChild<LLRadioGroup>("edit_radio_group");
  227. mBtnGridOptions = getChild<LLButton>("Options...");
  228. mTitleMedia = getChild<LLMediaCtrl>("title_media");
  230. mCheckSelectIndividual = getChild<LLCheckBoxCtrl>("checkbox edit linked parts");
  231. childSetValue("checkbox edit linked parts",(BOOL)gSavedSettings.getBOOL("EditLinkedParts"));
  232. mCheckSnapToGrid = getChild<LLCheckBoxCtrl>("checkbox snap to grid");
  233. childSetValue("checkbox snap to grid",(BOOL)gSavedSettings.getBOOL("SnapEnabled"));
  234. mCheckStretchUniform = getChild<LLCheckBoxCtrl>("checkbox uniform");
  235. childSetValue("checkbox uniform",(BOOL)gSavedSettings.getBOOL("ScaleUniform"));
  236. mCheckStretchTexture = getChild<LLCheckBoxCtrl>("checkbox stretch textures");
  237. childSetValue("checkbox stretch textures",(BOOL)gSavedSettings.getBOOL("ScaleStretchTextures"));
  238. mTextGridMode = getChild<LLTextBox>("text ruler mode");
  239. mComboGridMode = getChild<LLComboBox>("combobox grid mode");
  241. //
  242. // Create Buttons
  243. //
  245. for(size_t t=0; t<LL_ARRAY_SIZE(toolNames); ++t)
  246. {
  247. LLButton *found = getChild<LLButton>(toolNames[t]);
  248. if(found)
  249. {
  250. found->setClickedCallback(boost::bind(&LLFloaterTools::setObjectType, toolData[t]));
  251. mButtons.push_back( found );
  252. }else{
  253. llwarns << "Tool button not found! DOA Pending." << llendl;
  254. }
  255. }
  256. mCheckCopySelection = getChild<LLCheckBoxCtrl>("checkbox copy selection");
  257. childSetValue("checkbox copy selection",(BOOL)gSavedSettings.getBOOL("CreateToolCopySelection"));
  258. mCheckSticky = getChild<LLCheckBoxCtrl>("checkbox sticky");
  259. childSetValue("checkbox sticky",(BOOL)gSavedSettings.getBOOL("CreateToolKeepSelected"));
  260. mCheckCopyCenters = getChild<LLCheckBoxCtrl>("checkbox copy centers");
  261. childSetValue("checkbox copy centers",(BOOL)gSavedSettings.getBOOL("CreateToolCopyCenters"));
  262. mCheckCopyRotates = getChild<LLCheckBoxCtrl>("checkbox copy rotates");
  263. childSetValue("checkbox copy rotates",(BOOL)gSavedSettings.getBOOL("CreateToolCopyRotates"));
  265. mRadioGroupLand = getChild<LLRadioGroup>("land_radio_group");
  266. mBtnApplyToSelection = getChild<LLButton>("button apply to selection");
  267. mSliderDozerSize = getChild<LLSlider>("slider brush size");
  268. childSetValue( "slider brush size", gSavedSettings.getF32("LandBrushSize"));
  269. mSliderDozerForce = getChild<LLSlider>("slider force");
  270. // the setting stores the actual force multiplier, but the slider is logarithmic, so we convert here
  271. childSetValue( "slider force", log10(gSavedSettings.getF32("LandBrushForce")));
  273. mTab = getChild<LLTabContainer>("Object Info Tabs");
  274. if(mTab)
  275. {
  276. mTab->setFollows(FOLLOWS_TOP | FOLLOWS_LEFT);
  277. mTab->setBorderVisible(FALSE);
  278. mTab->selectFirstTab();
  279. }
  281. mStatusText["rotate"] = getString("status_rotate");
  282. mStatusText["scale"] = getString("status_scale");
  283. mStatusText["move"] = getString("status_move");
  284. mStatusText["modifyland"] = getString("status_modifyland");
  285. mStatusText["camera"] = getString("status_camera");
  286. mStatusText["grab"] = getString("status_grab");
  287. mStatusText["place"] = getString("status_place");
  288. mStatusText["selectland"] = getString("status_selectland");
  290. sShowObjectCost = gSavedSettings.getBOOL("ShowObjectRenderingCost");
  292. return TRUE;
  293. }
  295. // Create the popupview with a dummy center.  It will be moved into place
  296. // during LLViewerWindow's per-frame hover processing.
  297. LLFloaterTools::LLFloaterTools(const LLSD& key)
  298. : LLFloater(key),
  299. mBtnFocus(NULL),
  300. mBtnMove(NULL),
  301. mBtnEdit(NULL),
  302. mBtnCreate(NULL),
  303. mBtnLand(NULL),
  304. mTextStatus(NULL),
  306. mRadioGroupFocus(NULL),
  307. mRadioGroupMove(NULL),
  308. mRadioGroupEdit(NULL),
  310. mCheckSelectIndividual(NULL),
  312. mCheckSnapToGrid(NULL),
  313. mBtnGridOptions(NULL),
  314. mTitleMedia(NULL),
  315. mTextGridMode(NULL),
  316. mComboGridMode(NULL),
  317. mCheckStretchUniform(NULL),
  318. mCheckStretchTexture(NULL),
  320. mBtnRotateLeft(NULL),
  321. mBtnRotateReset(NULL),
  322. mBtnRotateRight(NULL),
  324. mBtnDelete(NULL),
  325. mBtnDuplicate(NULL),
  326. mBtnDuplicateInPlace(NULL),
  328. mCheckSticky(NULL),
  329. mCheckCopySelection(NULL),
  330. mCheckCopyCenters(NULL),
  331. mCheckCopyRotates(NULL),
  332. mRadioGroupLand(NULL),
  333. mSliderDozerSize(NULL),
  334. mSliderDozerForce(NULL),
  335. mBtnApplyToSelection(NULL),
  337. mTab(NULL),
  338. mPanelPermissions(NULL),
  339. mPanelObject(NULL),
  340. mPanelVolume(NULL),
  341. mPanelContents(NULL),
  342. mPanelFace(NULL),
  343. mPanelLandInfo(NULL),
  345. mTabLand(NULL),
  346. mDirty(TRUE),
  347. mNeedMediaTitle(TRUE)
  348. {
  349. gFloaterTools = this;
  351. setAutoFocus(FALSE);
  352. mFactoryMap["General"] = LLCallbackMap(createPanelPermissions, this);//LLPanelPermissions
  353. mFactoryMap["Object"] = LLCallbackMap(createPanelObject, this);//LLPanelObject
  354. mFactoryMap["Features"] = LLCallbackMap(createPanelVolume, this);//LLPanelVolume
  355. mFactoryMap["Texture"] = LLCallbackMap(createPanelFace, this);//LLPanelFace
  356. mFactoryMap["Contents"] = LLCallbackMap(createPanelContents, this);//LLPanelContents
  357. mFactoryMap["land info panel"] = LLCallbackMap(createPanelLandInfo, this);//LLPanelLandInfo
  359. //Called from floater reg: LLUICtrlFactory::getInstance()->buildFloater(this,"floater_tools.xml",FALSE);
  360. mCommitCallbackRegistrar.add("BuildTool.setTool", boost::bind(&LLFloaterTools::setTool,this, _2));
  361. mCommitCallbackRegistrar.add("BuildTool.commitZoom", boost::bind(&commit_slider_zoom, _1));
  362. mCommitCallbackRegistrar.add("BuildTool.commitRadioFocus", boost::bind(&commit_radio_group_focus, _1));
  363. mCommitCallbackRegistrar.add("BuildTool.commitRadioMove", boost::bind(&commit_radio_group_move,_1));
  364. mCommitCallbackRegistrar.add("BuildTool.commitRadioEdit", boost::bind(&commit_radio_group_edit,_1));
  366. mCommitCallbackRegistrar.add("BuildTool.selectComponent", boost::bind(&commit_select_component, this));
  367. mCommitCallbackRegistrar.add("BuildTool.gridOptions", boost::bind(&LLFloaterTools::onClickGridOptions,this));
  368. mCommitCallbackRegistrar.add("BuildTool.applyToSelection", boost::bind(&click_apply_to_selection, this));
  369. mCommitCallbackRegistrar.add("BuildTool.gridMode", boost::bind(&commit_grid_mode,_1));
  370. mCommitCallbackRegistrar.add("BuildTool.commitRadioLand", boost::bind(&commit_radio_group_land,_1));
  371. mCommitCallbackRegistrar.add("BuildTool.LandBrushForce", boost::bind(&commit_slider_dozer_force,_1));
  372. mCommitCallbackRegistrar.add("BuildTool.AddMedia", boost::bind(&LLFloaterTools::onClickBtnAddMedia,this));
  373. mCommitCallbackRegistrar.add("BuildTool.DeleteMedia", boost::bind(&LLFloaterTools::onClickBtnDeleteMedia,this));
  374. mCommitCallbackRegistrar.add("BuildTool.EditMedia", boost::bind(&LLFloaterTools::onClickBtnEditMedia,this));
  376. }
  378. LLFloaterTools::~LLFloaterTools()
  379. {
  380. // children automatically deleted
  381. gFloaterTools = NULL;
  382. }
  384. void LLFloaterTools::setStatusText(const std::string& text)
  385. {
  386. std::map<std::string, std::string>::iterator iter = mStatusText.find(text);
  387. if (iter != mStatusText.end())
  388. {
  389. mTextStatus->setText(iter->second);
  390. }
  391. else
  392. {
  393. mTextStatus->setText(text);
  394. }
  395. }
  397. void LLFloaterTools::refresh()
  398. {
  399. const S32 INFO_WIDTH = getRect().getWidth();
  400. const S32 INFO_HEIGHT = 384;
  401. LLRect object_info_rect(0, 0, INFO_WIDTH, -INFO_HEIGHT);
  402. BOOL all_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME );
  404. S32 idx_features = mTab->getPanelIndexByTitle(PANEL_NAMES[PANEL_FEATURES]);
  405. S32 idx_face = mTab->getPanelIndexByTitle(PANEL_NAMES[PANEL_FACE]);
  406. S32 idx_contents = mTab->getPanelIndexByTitle(PANEL_NAMES[PANEL_CONTENTS]);
  408. S32 selected_index = mTab->getCurrentPanelIndex();
  410. if (!all_volume && (selected_index == idx_features || selected_index == idx_face ||
  411. selected_index == idx_contents))
  412. {
  413. mTab->selectFirstTab();
  414. }
  416. mTab->enableTabButton(idx_features, all_volume);
  417. mTab->enableTabButton(idx_face, all_volume);
  418. mTab->enableTabButton(idx_contents, all_volume);
  420. // Refresh object and prim count labels
  421. LLLocale locale(LLLocale::USER_LOCALE);
  422. std::string obj_count_string;
  423. LLResMgr::getInstance()->getIntegerString(obj_count_string, LLSelectMgr::getInstance()->getSelection()->getRootObjectCount());
  424. childSetTextArg("obj_count",  "[COUNT]", obj_count_string);
  425. std::string prim_count_string;
  426. LLResMgr::getInstance()->getIntegerString(prim_count_string, LLSelectMgr::getInstance()->getSelection()->getObjectCount());
  427. childSetTextArg("prim_count", "[COUNT]", prim_count_string);
  429. // calculate selection rendering cost
  430. if (sShowObjectCost)
  431. {
  432. std::string prim_cost_string;
  433. LLResMgr::getInstance()->getIntegerString(prim_cost_string, calcRenderCost());
  434. childSetTextArg("RenderingCost", "[COUNT]", prim_cost_string);
  435. }
  438. // disable the object and prim counts if nothing selected
  439. bool have_selection = ! LLSelectMgr::getInstance()->getSelection()->isEmpty();
  440. childSetEnabled("obj_count", have_selection);
  441. childSetEnabled("prim_count", have_selection);
  442. childSetEnabled("RenderingCost", have_selection && sShowObjectCost);
  444. // Refresh child tabs
  445. mPanelPermissions->refresh();
  446. mPanelObject->refresh();
  447. mPanelVolume->refresh();
  448. mPanelFace->refresh();
  449. refreshMedia();
  450. mPanelContents->refresh();
  451. mPanelLandInfo->refresh();
  452. }
  454. void LLFloaterTools::draw()
  455. {
  456. if (mDirty)
  457. {
  458. refresh();
  459. mDirty = FALSE;
  460. }
  462. // grab media name/title and update the UI widget
  463. updateMediaTitle();
  465. // mCheckSelectIndividual->set(gSavedSettings.getBOOL("EditLinkedParts"));
  466. LLFloater::draw();
  467. }
  469. void LLFloaterTools::dirty()
  470. {
  471. mDirty = TRUE; 
  472. LLFloaterOpenObject* instance = LLFloaterReg::findTypedInstance<LLFloaterOpenObject>("openobject");
  473. if (instance) instance->dirty();
  474. }
  476. // Clean up any tool state that should not persist when the
  477. // floater is closed.
  478. void LLFloaterTools::resetToolState()
  479. {
  480. gCameraBtnZoom = TRUE;
  481. gCameraBtnOrbit = FALSE;
  482. gCameraBtnPan = FALSE;
  484. gGrabBtnSpin = FALSE;
  485. gGrabBtnVertical = FALSE;
  486. }
  488. void LLFloaterTools::updatePopup(LLCoordGL center, MASK mask)
  489. {
  490. LLTool *tool = LLToolMgr::getInstance()->getCurrentTool();
  492. // HACK to allow seeing the buttons when you have the app in a window.
  493. // Keep the visibility the same as it 
  494. if (tool == gToolNull)
  495. {
  496. return;
  497. }
  499. if ( isMinimized() )
  500. { // SL looks odd if we draw the tools while the window is minimized
  501. return;
  502. }
  504. // Focus buttons
  505. BOOL focus_visible = ( tool == LLToolCamera::getInstance() );
  507. mBtnFocus ->setToggleState( focus_visible );
  509. mRadioGroupFocus->setVisible( focus_visible );
  510. childSetVisible("slider zoom", focus_visible);
  511. childSetEnabled("slider zoom", gCameraBtnZoom);
  513. if (!gCameraBtnOrbit &&
  514. !gCameraBtnPan &&
  515. !(mask == MASK_ORBIT) &&
  516. !(mask == (MASK_ORBIT | MASK_ALT)) &&
  517. !(mask == MASK_PAN) &&
  518. !(mask == (MASK_PAN | MASK_ALT)) )
  519. {
  520. mRadioGroupFocus->setValue("radio zoom");
  521. }
  522. else if ( gCameraBtnOrbit || 
  523. (mask == MASK_ORBIT) ||
  524. (mask == (MASK_ORBIT | MASK_ALT)) )
  525. {
  526. mRadioGroupFocus->setValue("radio orbit");
  527. }
  528. else if ( gCameraBtnPan ||
  529. (mask == MASK_PAN) ||
  530. (mask == (MASK_PAN | MASK_ALT)) )
  531. {
  532. mRadioGroupFocus->setValue("radio pan");
  533. }
  535. // multiply by correction factor because volume sliders go [0, 0.5]
  536. childSetValue( "slider zoom", gAgent.getCameraZoomFraction() * 0.5f);
  538. // Move buttons
  539. BOOL move_visible = (tool == LLToolGrab::getInstance());
  541. if (mBtnMove) mBtnMove ->setToggleState( move_visible );
  543. // HACK - highlight buttons for next click
  544. mRadioGroupMove->setVisible(move_visible);
  545. if (!gGrabBtnSpin && 
  546. !gGrabBtnVertical &&
  547. !(mask == MASK_VERTICAL) && 
  548. !(mask == MASK_SPIN) )
  549. {
  550. mRadioGroupMove->setValue("radio move");
  551. }
  552. else if (gGrabBtnVertical || 
  553.  (mask == MASK_VERTICAL) )
  554. {
  555. mRadioGroupMove->setValue("radio lift");
  556. }
  557. else if (gGrabBtnSpin || 
  558.  (mask == MASK_SPIN) )
  559. {
  560. mRadioGroupMove->setValue("radio spin");
  561. }
  563. // Edit buttons
  564. BOOL edit_visible = tool == LLToolCompTranslate::getInstance() ||
  565. tool == LLToolCompRotate::getInstance() ||
  566. tool == LLToolCompScale::getInstance() ||
  567. tool == LLToolFace::getInstance() ||
  568. tool == LLToolIndividual::getInstance() ||
  569. tool == LLToolPipette::getInstance();
  571. mBtnEdit ->setToggleState( edit_visible );
  572. mRadioGroupEdit->setVisible( edit_visible );
  573. bool linked_parts = gSavedSettings.getBOOL("EditLinkedParts");
  574. childSetVisible("RenderingCost", !linked_parts && (edit_visible || focus_visible || move_visible) && sShowObjectCost);
  576. if (mCheckSelectIndividual)
  577. {
  578. mCheckSelectIndividual->setVisible(edit_visible);
  579. //mCheckSelectIndividual->set(gSavedSettings.getBOOL("EditLinkedParts"));
  580. }
  582. if ( tool == LLToolCompTranslate::getInstance() )
  583. {
  584. mRadioGroupEdit->setValue("radio position");
  585. }
  586. else if ( tool == LLToolCompRotate::getInstance() )
  587. {
  588. mRadioGroupEdit->setValue("radio rotate");
  589. }
  590. else if ( tool == LLToolCompScale::getInstance() )
  591. {
  592. mRadioGroupEdit->setValue("radio stretch");
  593. }
  594. else if ( tool == LLToolFace::getInstance() )
  595. {
  596. mRadioGroupEdit->setValue("radio select face");
  597. }
  599. if (mComboGridMode) 
  600. {
  601. mComboGridMode->setVisible( edit_visible );
  602. S32 index = mComboGridMode->getCurrentIndex();
  603. mComboGridMode->removeall();
  605. switch (mObjectSelection->getSelectType())
  606. {
  607. case SELECT_TYPE_HUD:
  608.   mComboGridMode->add(getString("grid_screen_text"));
  609.   mComboGridMode->add(getString("grid_local_text"));
  610.   //mComboGridMode->add(getString("grid_reference_text"));
  611.   break;
  612. case SELECT_TYPE_WORLD:
  613.   mComboGridMode->add(getString("grid_world_text"));
  614.   mComboGridMode->add(getString("grid_local_text"));
  615.   mComboGridMode->add(getString("grid_reference_text"));
  616.   break;
  617. case SELECT_TYPE_ATTACHMENT:
  618.   mComboGridMode->add(getString("grid_attachment_text"));
  619.   mComboGridMode->add(getString("grid_local_text"));
  620.   mComboGridMode->add(getString("grid_reference_text"));
  621.   break;
  622. }
  624. mComboGridMode->setCurrentByIndex(index);
  625. }
  626. if (mTextGridMode) mTextGridMode->setVisible( edit_visible );
  628. // Snap to grid disabled for grab tool - very confusing
  629. if (mCheckSnapToGrid) mCheckSnapToGrid->setVisible( edit_visible /* || tool == LLToolGrab::getInstance() */ );
  630. if (mBtnGridOptions) mBtnGridOptions->setVisible( edit_visible /* || tool == LLToolGrab::getInstance() */ );
  632. //mCheckSelectLinked ->setVisible( edit_visible );
  633. if (mCheckStretchUniform) mCheckStretchUniform->setVisible( edit_visible );
  634. if (mCheckStretchTexture) mCheckStretchTexture->setVisible( edit_visible );
  636. // Create buttons
  637. BOOL create_visible = (tool == LLToolCompCreate::getInstance());
  639. mBtnCreate ->setToggleState( tool == LLToolCompCreate::getInstance() );
  641. if (mCheckCopySelection
  642. && mCheckCopySelection->get())
  643. {
  644. // don't highlight any placer button
  645. for (std::vector<LLButton*>::size_type i = 0; i < mButtons.size(); i++)
  646. {
  647. mButtons[i]->setToggleState(FALSE);
  648. mButtons[i]->setVisible( create_visible );
  649. }
  650. }
  651. else
  652. {
  653. // Highlight the correct placer button
  654. for( S32 t = 0; t < (S32)mButtons.size(); t++ )
  655. {
  656. LLPCode pcode = LLToolPlacer::getObjectType();
  657. LLPCode button_pcode = toolData[t];
  658. BOOL state = (pcode == button_pcode);
  659. mButtons[t]->setToggleState( state );
  660. mButtons[t]->setVisible( create_visible );
  661. }
  662. }
  664. if (mCheckSticky) mCheckSticky ->setVisible( create_visible );
  665. if (mCheckCopySelection) mCheckCopySelection ->setVisible( create_visible );
  666. if (mCheckCopyCenters) mCheckCopyCenters ->setVisible( create_visible );
  667. if (mCheckCopyRotates) mCheckCopyRotates ->setVisible( create_visible );
  669. if (mCheckCopyCenters && mCheckCopySelection) mCheckCopyCenters->setEnabled( mCheckCopySelection->get() );
  670. if (mCheckCopyRotates && mCheckCopySelection) mCheckCopyRotates->setEnabled( mCheckCopySelection->get() );
  672. // Land buttons
  673. BOOL land_visible = (tool == LLToolBrushLand::getInstance() || tool == LLToolSelectLand::getInstance() );
  675. if (mBtnLand) mBtnLand ->setToggleState( land_visible );
  677. mRadioGroupLand->setVisible( land_visible );
  678. if ( tool == LLToolSelectLand::getInstance() )
  679. {
  680. mRadioGroupLand->setValue("radio select land");
  681. }
  682. else if ( tool == LLToolBrushLand::getInstance() )
  683. {
  684. S32 dozer_mode = gSavedSettings.getS32("RadioLandBrushAction");
  685. switch(dozer_mode)
  686. {
  687. case 0:
  688. mRadioGroupLand->setValue("radio flatten");
  689. break;
  690. case 1:
  691. mRadioGroupLand->setValue("radio raise");
  692. break;
  693. case 2:
  694. mRadioGroupLand->setValue("radio lower");
  695. break;
  696. case 3:
  697. mRadioGroupLand->setValue("radio smooth");
  698. break;
  699. case 4:
  700. mRadioGroupLand->setValue("radio noise");
  701. break;
  702. case 5:
  703. mRadioGroupLand->setValue("radio revert");
  704. break;
  705. default:
  706. break;
  707. }
  708. }
  710. if (mBtnApplyToSelection)
  711. {
  712. mBtnApplyToSelection->setVisible( land_visible );
  713. mBtnApplyToSelection->setEnabled( land_visible && !LLViewerParcelMgr::getInstance()->selectionEmpty() && tool != LLToolSelectLand::getInstance());
  714. }
  715. if (mSliderDozerSize)
  716. {
  717. mSliderDozerSize ->setVisible( land_visible );
  718. childSetVisible("Bulldozer:", land_visible);
  719. childSetVisible("Dozer Size:", land_visible);
  720. }
  721. if (mSliderDozerForce)
  722. {
  723. mSliderDozerForce ->setVisible( land_visible );
  724. childSetVisible("Strength:", land_visible);
  725. }
  727. childSetVisible("obj_count", !land_visible);
  728. childSetVisible("prim_count", !land_visible);
  729. mTab->setVisible(!land_visible);
  730. mPanelLandInfo->setVisible(land_visible);
  731. }
  734. // virtual
  735. BOOL LLFloaterTools::canClose()
  736. {
  737. // don't close when quitting, so camera will stay put
  738. return !LLApp::isExiting();
  739. }
  741. // virtual
  742. void LLFloaterTools::onOpen(const LLSD& key)
  743. {
  744. mParcelSelection = LLViewerParcelMgr::getInstance()->getFloatingParcelSelection();
  745. mObjectSelection = LLSelectMgr::getInstance()->getEditSelection();
  747. std::string panel = key.asString();
  748. if (!panel.empty())
  749. {
  750. mTab->selectTabByName(panel);
  751. }
  753. //gMenuBarView->setItemVisible("BuildTools", TRUE);
  754. }
  756. // virtual
  757. void LLFloaterTools::onClose(bool app_quitting)
  758. {
  759. mTab->setVisible(FALSE);
  761. LLViewerJoystick::getInstance()->moveAvatar(false);
  763. // destroy media source used to grab media title
  764. if( mTitleMedia )
  765. mTitleMedia->unloadMediaSource();
  767.     // Different from handle_reset_view in that it doesn't actually 
  768. //   move the camera if EditCameraMovement is not set.
  769. gAgent.resetView(gSavedSettings.getBOOL("EditCameraMovement"));
  771. // exit component selection mode
  772. LLSelectMgr::getInstance()->promoteSelectionToRoot();
  773. gSavedSettings.setBOOL("EditLinkedParts", FALSE);
  775. gViewerWindow->showCursor();
  777. resetToolState();
  779. mParcelSelection = NULL;
  780. mObjectSelection = NULL;
  782. // Switch back to basic toolset
  783. LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
  784. // we were already in basic toolset, using build tools
  785. // so manually reset tool to default (pie menu tool)
  786. LLToolMgr::getInstance()->getCurrentToolset()->selectFirstTool();
  788. //gMenuBarView->setItemVisible("BuildTools", FALSE);
  789. LLFloaterReg::hideInstance("media_settings");
  790. }
  792. void click_popup_info(void*)
  793. {
  794. }
  796. void click_popup_done(void*)
  797. {
  798. handle_reset_view();
  799. }
  801. void commit_radio_group_move(LLUICtrl* ctrl)
  802. {
  803. LLRadioGroup* group = (LLRadioGroup*)ctrl;
  804. std::string selected = group->getValue().asString();
  805. if (selected == "radio move")
  806. {
  807. gGrabBtnVertical = FALSE;
  808. gGrabBtnSpin = FALSE;
  809. }
  810. else if (selected == "radio lift")
  811. {
  812. gGrabBtnVertical = TRUE;
  813. gGrabBtnSpin = FALSE;
  814. }
  815. else if (selected == "radio spin")
  816. {
  817. gGrabBtnVertical = FALSE;
  818. gGrabBtnSpin = TRUE;
  819. }
  820. }
  822. void commit_radio_group_focus(LLUICtrl* ctrl)
  823. {
  824. LLRadioGroup* group = (LLRadioGroup*)ctrl;
  825. std::string selected = group->getValue().asString();
  826. if (selected == "radio zoom")
  827. {
  828. gCameraBtnZoom = TRUE;
  829. gCameraBtnOrbit = FALSE;
  830. gCameraBtnPan = FALSE;
  831. }
  832. else if (selected == "radio orbit")
  833. {
  834. gCameraBtnZoom = FALSE;
  835. gCameraBtnOrbit = TRUE;
  836. gCameraBtnPan = FALSE;
  837. }
  838. else if (selected == "radio pan")
  839. {
  840. gCameraBtnZoom = FALSE;
  841. gCameraBtnOrbit = FALSE;
  842. gCameraBtnPan = TRUE;
  843. }
  844. }
  846. void commit_slider_zoom(LLUICtrl *ctrl)
  847. {
  848. // renormalize value, since max "volume" level is 0.5 for some reason
  849. F32 zoom_level = (F32)ctrl->getValue().asReal() * 2.f; // / 0.5f;
  850. gAgent.setCameraZoomFraction(zoom_level);
  851. }
  853. void click_popup_rotate_left(void*)
  854. {
  855. LLSelectMgr::getInstance()->selectionRotateAroundZ( 45.f );
  856. dialog_refresh_all();
  857. }
  859. void click_popup_rotate_reset(void*)
  860. {
  861. LLSelectMgr::getInstance()->selectionResetRotation();
  862. dialog_refresh_all();
  863. }
  865. void click_popup_rotate_right(void*)
  866. {
  867. LLSelectMgr::getInstance()->selectionRotateAroundZ( -45.f );
  868. dialog_refresh_all();
  869. }
  871. void commit_slider_dozer_force(LLUICtrl *ctrl)
  872. {
  873. // the slider is logarithmic, so we exponentiate to get the actual force multiplier
  874. F32 dozer_force = pow(10.f, (F32)ctrl->getValue().asReal());
  875. gSavedSettings.setF32("LandBrushForce", dozer_force);
  876. }
  878. void click_apply_to_selection(void*)
  879. {
  880. LLToolBrushLand::getInstance()->modifyLandInSelectionGlobal();
  881. }
  883. void commit_radio_group_edit(LLUICtrl *ctrl)
  884. {
  885. S32 show_owners = gSavedSettings.getBOOL("ShowParcelOwners");
  887. LLRadioGroup* group = (LLRadioGroup*)ctrl;
  888. std::string selected = group->getValue().asString();
  889. if (selected == "radio position")
  890. {
  891. LLFloaterTools::setEditTool( LLToolCompTranslate::getInstance() );
  892. }
  893. else if (selected == "radio rotate")
  894. {
  895. LLFloaterTools::setEditTool( LLToolCompRotate::getInstance() );
  896. }
  897. else if (selected == "radio stretch")
  898. {
  899. LLFloaterTools::setEditTool( LLToolCompScale::getInstance() );
  900. }
  901. else if (selected == "radio select face")
  902. {
  903. LLFloaterTools::setEditTool( LLToolFace::getInstance() );
  904. }
  905. gSavedSettings.setBOOL("ShowParcelOwners", show_owners);
  906. }
  908. void commit_radio_group_land(LLUICtrl* ctrl)
  909. {
  910. LLRadioGroup* group = (LLRadioGroup*)ctrl;
  911. std::string selected = group->getValue().asString();
  912. if (selected == "radio select land")
  913. {
  914. LLFloaterTools::setEditTool( LLToolSelectLand::getInstance() );
  915. }
  916. else
  917. {
  918. LLFloaterTools::setEditTool( LLToolBrushLand::getInstance() );
  919. S32 dozer_mode = gSavedSettings.getS32("RadioLandBrushAction");
  920. if (selected == "radio flatten")
  921. dozer_mode = 0;
  922. else if (selected == "radio raise")
  923. dozer_mode = 1;
  924. else if (selected == "radio lower")
  925. dozer_mode = 2;
  926. else if (selected == "radio smooth")
  927. dozer_mode = 3;
  928. else if (selected == "radio noise")
  929. dozer_mode = 4;
  930. else if (selected == "radio revert")
  931. dozer_mode = 5;
  932. gSavedSettings.setS32("RadioLandBrushAction", dozer_mode);
  933. }
  934. }
  936. void commit_select_component(void *data)
  937. {
  938. LLFloaterTools* floaterp = (LLFloaterTools*)data;
  940. //forfeit focus
  941. if (gFocusMgr.childHasKeyboardFocus(floaterp))
  942. {
  943. gFocusMgr.setKeyboardFocus(NULL);
  944. }
  946. BOOL select_individuals = floaterp->mCheckSelectIndividual->get();
  947. gSavedSettings.setBOOL("EditLinkedParts", select_individuals);
  948. floaterp->dirty();
  950. if (select_individuals)
  951. {
  952. LLSelectMgr::getInstance()->demoteSelectionToIndividuals();
  953. }
  954. else
  955. {
  956. LLSelectMgr::getInstance()->promoteSelectionToRoot();
  957. }
  958. }
  960. void commit_grid_mode(LLUICtrl *ctrl)   
  961. {   
  962. LLComboBox* combo = (LLComboBox*)ctrl;   
  963.     
  964. LLSelectMgr::getInstance()->setGridMode((EGridMode)combo->getCurrentIndex());
  965. } 
  967. // static 
  968. void LLFloaterTools::setObjectType( LLPCode pcode )
  969. {
  970. LLToolPlacer::setObjectType( pcode );
  971. gSavedSettings.setBOOL("CreateToolCopySelection", FALSE);
  972. gFocusMgr.setMouseCapture(NULL);
  973. }
  976. void LLFloaterTools::onClickGridOptions()
  977. {
  978. LLFloaterReg::showInstance("build_options");
  979. // RN: this makes grid options dependent on build tools window
  980. //floaterp->addDependentFloater(LLFloaterBuildOptions::getInstance(), FALSE);
  981. }
  983. S32 LLFloaterTools::calcRenderCost()
  984. {
  985. S32 cost = 0;
  986. std::set<LLUUID> textures;
  988. for (LLObjectSelection::iterator selection_iter = LLSelectMgr::getInstance()->getSelection()->begin();
  989.   selection_iter != LLSelectMgr::getInstance()->getSelection()->end();
  990.   ++selection_iter)
  991. {
  992. LLSelectNode *select_node = *selection_iter;
  993. if (select_node)
  994. {
  995. LLVOVolume *viewer_volume = (LLVOVolume*)select_node->getObject();
  996. if (viewer_volume)
  997. {
  998. cost += viewer_volume->getRenderCost(textures);
  999. cost += textures.size() * LLVOVolume::ARC_TEXTURE_COST;
  1000. textures.clear();
  1001. }
  1002. }
  1003. }
  1006. return cost;
  1007. }
  1009. // static
  1010. void LLFloaterTools::setEditTool(void* tool_pointer)
  1011. {
  1012. LLTool *tool = (LLTool *)tool_pointer;
  1013. LLToolMgr::getInstance()->getCurrentToolset()->selectTool( tool );
  1014. }
  1016. void LLFloaterTools::setTool(const LLSD& user_data)
  1017. {
  1018. std::string control_name = user_data.asString();
  1019. if(control_name == "Focus")
  1020. LLToolMgr::getInstance()->getCurrentToolset()->selectTool((LLTool *) LLToolCamera::getInstance() );
  1021. else if (control_name == "Move" )
  1022. LLToolMgr::getInstance()->getCurrentToolset()->selectTool( (LLTool *)LLToolGrab::getInstance() );
  1023. else if (control_name == "Edit" )
  1024. LLToolMgr::getInstance()->getCurrentToolset()->selectTool( (LLTool *) LLToolCompTranslate::getInstance());
  1025. else if (control_name == "Create" )
  1026. LLToolMgr::getInstance()->getCurrentToolset()->selectTool( (LLTool *) LLToolCompCreate::getInstance());
  1027. else if (control_name == "Land" )
  1028. LLToolMgr::getInstance()->getCurrentToolset()->selectTool( (LLTool *) LLToolSelectLand::getInstance());
  1029. else
  1030. llwarns<<" no parameter name "<<control_name<<" found!! No Tool selected!!"<< llendl;
  1031. }
  1033. void LLFloaterTools::onFocusReceived()
  1034. {
  1035. LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
  1036. LLFloater::onFocusReceived();
  1037. }
  1039. // Media stuff
  1040. void LLFloaterTools::refreshMedia()
  1041. {
  1042. getMediaState();
  1043. }
  1045. bool LLFloaterTools::selectedMediaEditable()
  1046. {
  1047. U32 owner_mask_on;
  1048. U32 owner_mask_off;
  1049. U32 valid_owner_perms = LLSelectMgr::getInstance()->selectGetPerm( PERM_OWNER, 
  1050.   &owner_mask_on, &owner_mask_off );
  1051. U32 group_mask_on;
  1052. U32 group_mask_off;
  1053. U32 valid_group_perms = LLSelectMgr::getInstance()->selectGetPerm( PERM_GROUP, 
  1054.   &group_mask_on, &group_mask_off );
  1055. U32 everyone_mask_on;
  1056. U32 everyone_mask_off;
  1057. S32 valid_everyone_perms = LLSelectMgr::getInstance()->selectGetPerm( PERM_EVERYONE, 
  1058.  &everyone_mask_on, &everyone_mask_off );
  1060. bool selected_Media_editable = false;
  1062. // if perms we got back are valid
  1063. if ( valid_owner_perms &&
  1064. valid_group_perms && 
  1065. valid_everyone_perms )
  1066. {
  1068. if ( ( owner_mask_on & PERM_MODIFY ) ||
  1069. ( group_mask_on & PERM_MODIFY ) || 
  1070. ( group_mask_on & PERM_MODIFY ) )
  1071. {
  1072. selected_Media_editable = true;
  1073. }
  1074. else
  1075. // user is NOT allowed to press the RESET button
  1076. {
  1077. selected_Media_editable = false;
  1078. };
  1079. };
  1081. return selected_Media_editable;
  1082. }
  1084. void LLFloaterTools::getMediaState()
  1085. {
  1086. LLObjectSelectionHandle selected_objects =LLSelectMgr::getInstance()->getSelection();
  1087. LLViewerObject* first_object = selected_objects->getFirstObject();
  1088. LLTextBox* media_info = getChild<LLTextBox>("media_info");
  1090. if( !(first_object 
  1091.   && first_object->getPCode() == LL_PCODE_VOLUME
  1092.   &&first_object->permModify() 
  1093.       ))
  1094. {
  1095. childSetEnabled("Add_Media",  FALSE);
  1096. media_info->clear();
  1097. clearMediaSettings();
  1098. return;
  1099. }
  1101. std::string url = first_object->getRegion()->getCapability("ObjectMedia");
  1102. bool has_media_capability = (!url.empty());
  1104. if(!has_media_capability)
  1105. {
  1106. childSetEnabled("Add_Media",  FALSE);
  1107. LL_WARNS("LLFloaterTools: media") << "Media not enabled (no capability) in this region!" << LL_ENDL;
  1108. clearMediaSettings();
  1109. return;
  1110. }
  1112. bool editable = (first_object->permModify() || selectedMediaEditable());
  1114. // Check modify permissions and whether any selected objects are in
  1115. // the process of being fetched.  If they are, then we're not editable
  1116. if (editable)
  1117. {
  1118. LLObjectSelection::iterator iter = selected_objects->begin(); 
  1119. LLObjectSelection::iterator end = selected_objects->end();
  1120. for ( ; iter != end; ++iter)
  1121. {
  1122. LLSelectNode* node = *iter;
  1123. LLVOVolume* object = dynamic_cast<LLVOVolume*>(node->getObject());
  1124. if (NULL != object)
  1125. {
  1126. if (!object->permModify())
  1127. {
  1128. LL_INFOS("LLFloaterTools: media")
  1129. << "Selection not editable due to lack of modify permissions on object id "
  1130. << object->getID() << LL_ENDL;
  1132. editable = false;
  1133. break;
  1134. }
  1135. // XXX DISABLE this for now, because when the fetch finally 
  1136. // does come in, the state of this floater doesn't properly
  1137. // update.  Re-selecting fixes the problem, but there is 
  1138. // contention as to whether this is a sufficient solution.
  1139. // if (object->isMediaDataBeingFetched())
  1140. // {
  1141. // LL_INFOS("LLFloaterTools: media")
  1142. // << "Selection not editable due to media data being fetched for object id "
  1143. // << object->getID() << LL_ENDL;
  1144. //
  1145. // editable = false;
  1146. // break;
  1147. // }
  1148. }
  1149. }
  1150. }
  1152. // Media settings
  1153. bool bool_has_media = false;
  1154. struct media_functor : public LLSelectedTEGetFunctor<bool>
  1155. {
  1156. bool get(LLViewerObject* object, S32 face)
  1157. {
  1158. LLTextureEntry *te = object->getTE(face);
  1159. if (te)
  1160. {
  1161. return te->hasMedia();
  1162. }
  1163. return false;
  1164. }
  1165. } func;
  1167. // check if all faces have media(or, all dont have media)
  1168. LLFloaterMediaSettings::getInstance()->mIdenticalHasMediaInfo = selected_objects->getSelectedTEValue( &func, bool_has_media );
  1170. const LLMediaEntry default_media_data;
  1172. struct functor_getter_media_data : public LLSelectedTEGetFunctor< LLMediaEntry>
  1173.     {
  1174. functor_getter_media_data(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1176.         LLMediaEntry get( LLViewerObject* object, S32 face )
  1177.         {
  1178.             if ( object )
  1179.                 if ( object->getTE(face) )
  1180.                     if ( object->getTE(face)->getMediaData() )
  1181.                         return *(object->getTE(face)->getMediaData());
  1182. return mMediaEntry;
  1183.         };
  1185. const LLMediaEntry& mMediaEntry;
  1187.     } func_media_data(default_media_data);
  1189. LLMediaEntry media_data_get;
  1190.     LLFloaterMediaSettings::getInstance()->mMultipleMedia = !(selected_objects->getSelectedTEValue( &func_media_data, media_data_get ));
  1192. std::string multi_media_info_str = LLTrans::getString("Multiple Media");
  1193. std::string media_title = "";
  1194. mNeedMediaTitle = false;
  1195. // update UI depending on whether "object" (prim or face) has media
  1196. // and whether or not you are allowed to edit it.
  1198. childSetEnabled("Add_Media",  editable);
  1199. // IF all the faces have media (or all dont have media)
  1200. if ( LLFloaterMediaSettings::getInstance()->mIdenticalHasMediaInfo )
  1201. {
  1202. // TODO: get media title and set it.
  1203. media_info->clear();
  1204. // if identical is set, all faces are same (whether all empty or has the same media)
  1205. if(!(LLFloaterMediaSettings::getInstance()->mMultipleMedia) )
  1206. {
  1207. // Media data is valid
  1208. if(media_data_get!=default_media_data)
  1209. {
  1210. // initial media title is the media URL (until we get the name)
  1211. media_title = media_data_get.getHomeURL();
  1213. // kick off a navigate and flag that we need to update the title
  1214. navigateToTitleMedia( media_data_get.getHomeURL() );
  1215. mNeedMediaTitle = true;
  1216. }
  1217. // else all faces might be empty. 
  1218. }
  1219. else // there' re Different Medias' been set on on the faces.
  1220. {
  1221. media_title = multi_media_info_str;
  1222. mNeedMediaTitle = false;
  1223. }
  1225. childSetEnabled("media_tex",  bool_has_media && editable);
  1226. childSetEnabled( "edit_media", bool_has_media && LLFloaterMediaSettings::getInstance()->mIdenticalHasMediaInfo && editable );
  1227. childSetEnabled( "delete_media", bool_has_media && editable );
  1228. childSetEnabled( "add_media", ( ! bool_has_media ) && editable );
  1229. // TODO: display a list of all media on the face - use 'identical' flag
  1230. }
  1231. else // not all face has media but at least one does.
  1232. {
  1233. // seleted faces have not identical value
  1234. LLFloaterMediaSettings::getInstance()->mMultipleValidMedia = selected_objects->isMultipleTEValue(&func_media_data, default_media_data );
  1236. if(LLFloaterMediaSettings::getInstance()->mMultipleValidMedia)
  1237. {
  1238. media_title = multi_media_info_str;
  1239. mNeedMediaTitle = false;
  1240. }
  1241. else
  1242. {
  1243. // Media data is valid
  1244. if(media_data_get!=default_media_data)
  1245. {
  1246. // initial media title is the media URL (until we get the name)
  1247. media_title = media_data_get.getHomeURL();
  1249. // kick off a navigate and flag that we need to update the title
  1250. navigateToTitleMedia( media_data_get.getHomeURL() );
  1251. mNeedMediaTitle = true;
  1252. }
  1253. }
  1255. childSetEnabled("media_tex",  TRUE);
  1256. childSetEnabled( "edit_media", LLFloaterMediaSettings::getInstance()->mIdenticalHasMediaInfo);
  1257. childSetEnabled( "delete_media", TRUE);
  1258. childSetEnabled( "add_media", FALSE );
  1259. }
  1260. media_info->setText(media_title);
  1262. // load values for media settings
  1263. updateMediaSettings();
  1265. LLFloaterMediaSettings::initValues(mMediaSettings, editable );
  1266. }
  1269. //////////////////////////////////////////////////////////////////////////////
  1270. // called when a user wants to add media to a prim or prim face
  1271. void LLFloaterTools::onClickBtnAddMedia()
  1272. {
  1273. // check if multiple faces are selected
  1274. if(LLSelectMgr::getInstance()->getSelection()->isMultipleTESelected())
  1275. {
  1276. LLNotificationsUtil::add("MultipleFacesSelected", LLSD(), LLSD(), multipleFacesSelectedConfirm);
  1277. }
  1278. else
  1279. {
  1280. onClickBtnEditMedia();
  1281. }
  1282. }
  1284. // static
  1285. bool LLFloaterTools::multipleFacesSelectedConfirm(const LLSD& notification, const LLSD& response)
  1286. {
  1287. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  1288. switch( option )
  1289. {
  1290. case 0:  // "Yes"
  1291. gFloaterTools->onClickBtnEditMedia();
  1292. break;
  1293. case 1:  // "No"
  1294. default:
  1295. break;
  1296. }
  1297. return false;
  1298. }
  1300. //////////////////////////////////////////////////////////////////////////////
  1301. // called when a user wants to edit existing media settings on a prim or prim face
  1302. // TODO: test if there is media on the item and only allow editing if present
  1303. void LLFloaterTools::onClickBtnEditMedia()
  1304. {
  1305. refreshMedia();
  1306. LLFloaterReg::showInstance("media_settings");
  1307. }
  1309. //////////////////////////////////////////////////////////////////////////////
  1310. // called when a user wants to delete media from a prim or prim face
  1311. void LLFloaterTools::onClickBtnDeleteMedia()
  1312. {
  1313. LLNotificationsUtil::add("DeleteMedia", LLSD(), LLSD(), deleteMediaConfirm);
  1314. }
  1317. // static
  1318. bool LLFloaterTools::deleteMediaConfirm(const LLSD& notification, const LLSD& response)
  1319. {
  1320. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  1321. switch( option )
  1322. {
  1323. case 0:  // "Yes"
  1324. LLSelectMgr::getInstance()->selectionSetMedia( 0, LLSD() );
  1325. if(LLFloaterReg::instanceVisible("media_settings"))
  1326. {
  1327. LLFloaterReg::hideInstance("media_settings");
  1328. }
  1329. break;
  1331. case 1:  // "No"
  1332. default:
  1333. break;
  1334. }
  1335. return false;
  1336. }
  1338. //////////////////////////////////////////////////////////////////////////////
  1339. //
  1340. void LLFloaterTools::clearMediaSettings()
  1341. {
  1342. LLFloaterMediaSettings::getInstance();
  1343. LLFloaterMediaSettings::clearValues(false);
  1345. }
  1347. //////////////////////////////////////////////////////////////////////////////
  1348. //
  1349. void LLFloaterTools::navigateToTitleMedia( const std::string url )
  1350. {
  1351. if ( mTitleMedia )
  1352. {
  1353. LLPluginClassMedia* media_plugin = mTitleMedia->getMediaPlugin();
  1354. if ( media_plugin )
  1355. {
  1356. // if it's a movie, we don't want to hear it
  1357. media_plugin->setVolume( 0 );
  1358. };
  1359. mTitleMedia->navigateTo( url );
  1360. };
  1361. }
  1363. //////////////////////////////////////////////////////////////////////////////
  1364. //
  1365. void LLFloaterTools::updateMediaTitle()
  1366. {
  1367. // only get the media name if we need it
  1368. if ( ! mNeedMediaTitle )
  1369. return;
  1371. // get plugin impl
  1372. LLPluginClassMedia* media_plugin = mTitleMedia->getMediaPlugin();
  1373. if ( media_plugin )
  1374. {
  1375. // get the media name (asynchronous - must call repeatedly)
  1376. std::string media_title = media_plugin->getMediaName();
  1378. // only replace the title if what we get contains something
  1379. if ( ! media_title.empty() )
  1380. {
  1381. // update the UI widget
  1382. LLTextBox* media_title_field = getChild<LLTextBox>("media_info");
  1383. if ( media_title_field )
  1384. {
  1385. media_title_field->setText( media_title );
  1387. // stop looking for a title when we get one
  1388. // FIXME: check this is the right approach
  1389. mNeedMediaTitle = false;
  1390. };
  1391. };
  1392. };
  1393. }
  1395. //////////////////////////////////////////////////////////////////////////////
  1396. //
  1397. void LLFloaterTools::updateMediaSettings()
  1398. {
  1399.     bool identical( false );
  1400.     std::string base_key( "" );
  1401.     std::string value_str( "" );
  1402.     int value_int = 0;
  1403.     bool value_bool = false;
  1404. LLObjectSelectionHandle selected_objects =LLSelectMgr::getInstance()->getSelection();
  1405.     // TODO: (CP) refactor this using something clever or boost or both !!
  1407.     const LLMediaEntry default_media_data;
  1409.     // controls 
  1410.     U8 value_u8 = default_media_data.getControls();
  1411.     struct functor_getter_controls : public LLSelectedTEGetFunctor< U8 >
  1412.     {
  1413. functor_getter_controls(const LLMediaEntry &entry) : mMediaEntry(entry) {}
  1415.         U8 get( LLViewerObject* object, S32 face )
  1416.         {
  1417.             if ( object )
  1418.                 if ( object->getTE(face) )
  1419.                     if ( object->getTE(face)->getMediaData() )
  1420.                         return object->getTE(face)->getMediaData()->getControls();
  1421.             return mMediaEntry.getControls();
  1422.         };
  1424. const LLMediaEntry &mMediaEntry;
  1426.     } func_controls(default_media_data);
  1427.     identical = selected_objects->getSelectedTEValue( &func_controls, value_u8 );
  1428.     base_key = std::string( LLMediaEntry::CONTROLS_KEY );
  1429.     mMediaSettings[ base_key ] = value_u8;
  1430.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1432.     // First click (formerly left click)
  1433.     value_bool = default_media_data.getFirstClickInteract();
  1434.     struct functor_getter_first_click : public LLSelectedTEGetFunctor< bool >
  1435.     {
  1436. functor_getter_first_click(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1438.         bool get( LLViewerObject* object, S32 face )
  1439.         {
  1440.             if ( object )
  1441.                 if ( object->getTE(face) )
  1442.                     if ( object->getTE(face)->getMediaData() )
  1443.                         return object->getTE(face)->getMediaData()->getFirstClickInteract();
  1444.             return mMediaEntry.getFirstClickInteract();
  1445.         };
  1447. const LLMediaEntry &mMediaEntry;
  1449.     } func_first_click(default_media_data);
  1450.     identical = selected_objects->getSelectedTEValue( &func_first_click, value_bool );
  1451.     base_key = std::string( LLMediaEntry::FIRST_CLICK_INTERACT_KEY );
  1452.     mMediaSettings[ base_key ] = value_bool;
  1453.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1455.     // Home URL
  1456.     value_str = default_media_data.getHomeURL();
  1457.     struct functor_getter_home_url : public LLSelectedTEGetFunctor< std::string >
  1458.     {
  1459. functor_getter_home_url(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1461.         std::string get( LLViewerObject* object, S32 face )
  1462.         {
  1463.             if ( object )
  1464.                 if ( object->getTE(face) )
  1465.                     if ( object->getTE(face)->getMediaData() )
  1466.                         return object->getTE(face)->getMediaData()->getHomeURL();
  1467.             return mMediaEntry.getHomeURL();
  1468.         };
  1470. const LLMediaEntry &mMediaEntry;
  1472.     } func_home_url(default_media_data);
  1473.     identical = selected_objects->getSelectedTEValue( &func_home_url, value_str );
  1474.     base_key = std::string( LLMediaEntry::HOME_URL_KEY );
  1475.     mMediaSettings[ base_key ] = value_str;
  1476.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1478.     // Current URL
  1479.     value_str = default_media_data.getCurrentURL();
  1480.     struct functor_getter_current_url : public LLSelectedTEGetFunctor< std::string >
  1481.     {
  1482. functor_getter_current_url(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1483.         
  1484. std::string get( LLViewerObject* object, S32 face )
  1485.         {
  1486.             if ( object )
  1487.                 if ( object->getTE(face) )
  1488.                     if ( object->getTE(face)->getMediaData() )
  1489.                         return object->getTE(face)->getMediaData()->getCurrentURL();
  1490.             return mMediaEntry.getCurrentURL();
  1491.         };
  1493. const LLMediaEntry &mMediaEntry;
  1495.     } func_current_url(default_media_data);
  1496.     identical = selected_objects->getSelectedTEValue( &func_current_url, value_str );
  1497.     base_key = std::string( LLMediaEntry::CURRENT_URL_KEY );
  1498.     mMediaSettings[ base_key ] = value_str;
  1499.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1501.     // Auto zoom
  1502.     value_bool = default_media_data.getAutoZoom();
  1503.     struct functor_getter_auto_zoom : public LLSelectedTEGetFunctor< bool >
  1504.     {
  1506. functor_getter_auto_zoom(const LLMediaEntry& entry) : mMediaEntry(entry) {}
  1508.         bool get( LLViewerObject* object, S32 face )
  1509.         {
  1510.             if ( object )
  1511.                 if ( object->getTE(face) )
  1512.                     if ( object->getTE(face)->getMediaData() )
  1513.                         return object->getTE(face)->getMediaData()->getAutoZoom();
  1514.             return mMediaEntry.getAutoZoom();
  1515.         };
  1517. const LLMediaEntry &mMediaEntry;
  1519.     } func_auto_zoom(default_media_data);
  1520.     identical = selected_objects->getSelectedTEValue( &func_auto_zoom, value_bool );
  1521.     base_key = std::string( LLMediaEntry::AUTO_ZOOM_KEY );
  1522.     mMediaSettings[ base_key ] = value_bool;
  1523.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1525.     // Auto play
  1526.     //value_bool = default_media_data.getAutoPlay();
  1527. // set default to auto play TRUE -- angela  EXT-5172
  1528. value_bool = true;
  1529.     struct functor_getter_auto_play : public LLSelectedTEGetFunctor< bool >
  1530.     {
  1531. functor_getter_auto_play(const LLMediaEntry& entry) : mMediaEntry(entry) {}
  1533.         bool get( LLViewerObject* object, S32 face )
  1534.         {
  1535.             if ( object )
  1536.                 if ( object->getTE(face) )
  1537.                     if ( object->getTE(face)->getMediaData() )
  1538.                         return object->getTE(face)->getMediaData()->getAutoPlay();
  1539.             //return mMediaEntry.getAutoPlay(); set default to auto play TRUE -- angela  EXT-5172
  1540. return true;
  1541.         };
  1543. const LLMediaEntry &mMediaEntry;
  1545.     } func_auto_play(default_media_data);
  1546.     identical = selected_objects->getSelectedTEValue( &func_auto_play, value_bool );
  1547.     base_key = std::string( LLMediaEntry::AUTO_PLAY_KEY );
  1548.     mMediaSettings[ base_key ] = value_bool;
  1549.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1552.     // Auto scale
  1553. // set default to auto scale TRUE -- angela  EXT-5172
  1554.     //value_bool = default_media_data.getAutoScale();
  1555. value_bool = true;
  1556.     struct functor_getter_auto_scale : public LLSelectedTEGetFunctor< bool >
  1557.     {
  1558. functor_getter_auto_scale(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1560.         bool get( LLViewerObject* object, S32 face )
  1561.         {
  1562.             if ( object )
  1563.                 if ( object->getTE(face) )
  1564.                     if ( object->getTE(face)->getMediaData() )
  1565.                         return object->getTE(face)->getMediaData()->getAutoScale();
  1566.            // return mMediaEntry.getAutoScale();  set default to auto scale TRUE -- angela  EXT-5172
  1567. return true;
  1568. };
  1570. const LLMediaEntry &mMediaEntry;
  1572.     } func_auto_scale(default_media_data);
  1573.     identical = selected_objects->getSelectedTEValue( &func_auto_scale, value_bool );
  1574.     base_key = std::string( LLMediaEntry::AUTO_SCALE_KEY );
  1575.     mMediaSettings[ base_key ] = value_bool;
  1576.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1578.     // Auto loop
  1579.     value_bool = default_media_data.getAutoLoop();
  1580.     struct functor_getter_auto_loop : public LLSelectedTEGetFunctor< bool >
  1581.     {
  1582. functor_getter_auto_loop(const LLMediaEntry& entry) : mMediaEntry(entry) {}
  1584.         bool get( LLViewerObject* object, S32 face )
  1585.         {
  1586.             if ( object )
  1587.                 if ( object->getTE(face) )
  1588.                     if ( object->getTE(face)->getMediaData() )
  1589.                         return object->getTE(face)->getMediaData()->getAutoLoop();
  1590.             return mMediaEntry.getAutoLoop();
  1591.         };
  1593. const LLMediaEntry &mMediaEntry;
  1595.     } func_auto_loop(default_media_data);
  1596.     identical = selected_objects->getSelectedTEValue( &func_auto_loop, value_bool );
  1597.     base_key = std::string( LLMediaEntry::AUTO_LOOP_KEY );
  1598.     mMediaSettings[ base_key ] = value_bool;
  1599.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1601.     // width pixels (if not auto scaled)
  1602.     value_int = default_media_data.getWidthPixels();
  1603.     struct functor_getter_width_pixels : public LLSelectedTEGetFunctor< int >
  1604.     {
  1605. functor_getter_width_pixels(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1607.         int get( LLViewerObject* object, S32 face )
  1608.         {
  1609.             if ( object )
  1610.                 if ( object->getTE(face) )
  1611.                     if ( object->getTE(face)->getMediaData() )
  1612.                         return object->getTE(face)->getMediaData()->getWidthPixels();
  1613.             return mMediaEntry.getWidthPixels();
  1614.         };
  1616. const LLMediaEntry &mMediaEntry;
  1618.     } func_width_pixels(default_media_data);
  1619.     identical = selected_objects->getSelectedTEValue( &func_width_pixels, value_int );
  1620.     base_key = std::string( LLMediaEntry::WIDTH_PIXELS_KEY );
  1621.     mMediaSettings[ base_key ] = value_int;
  1622.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1624.     // height pixels (if not auto scaled)
  1625.     value_int = default_media_data.getHeightPixels();
  1626.     struct functor_getter_height_pixels : public LLSelectedTEGetFunctor< int >
  1627.     {
  1628. functor_getter_height_pixels(const LLMediaEntry& entry) : mMediaEntry(entry) {}
  1629.         
  1630. int get( LLViewerObject* object, S32 face )
  1631.         {
  1632.             if ( object )
  1633.                 if ( object->getTE(face) )
  1634.                     if ( object->getTE(face)->getMediaData() )
  1635.                         return object->getTE(face)->getMediaData()->getHeightPixels();
  1636.             return mMediaEntry.getHeightPixels();
  1637.         };
  1639. const LLMediaEntry &mMediaEntry;
  1641.     } func_height_pixels(default_media_data);
  1642.     identical = selected_objects->getSelectedTEValue( &func_height_pixels, value_int );
  1643.     base_key = std::string( LLMediaEntry::HEIGHT_PIXELS_KEY );
  1644.     mMediaSettings[ base_key ] = value_int;
  1645.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1647.     // Enable Alt image
  1648.     value_bool = default_media_data.getAltImageEnable();
  1649.     struct functor_getter_enable_alt_image : public LLSelectedTEGetFunctor< bool >
  1650.     {
  1651. functor_getter_enable_alt_image(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1652.         
  1653. bool get( LLViewerObject* object, S32 face )
  1654.         {
  1655.             if ( object )
  1656.                 if ( object->getTE(face) )
  1657.                     if ( object->getTE(face)->getMediaData() )
  1658.                         return object->getTE(face)->getMediaData()->getAltImageEnable();
  1659.             return mMediaEntry.getAltImageEnable();
  1660.         };
  1662. const LLMediaEntry &mMediaEntry;
  1664.     } func_enable_alt_image(default_media_data);
  1665.     identical = selected_objects->getSelectedTEValue( &func_enable_alt_image, value_bool );
  1666.     base_key = std::string( LLMediaEntry::ALT_IMAGE_ENABLE_KEY );
  1667.     mMediaSettings[ base_key ] = value_bool;
  1668.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1670.     // Perms - owner interact
  1671.     value_bool = 0 != ( default_media_data.getPermsInteract() & LLMediaEntry::PERM_OWNER );
  1672.     struct functor_getter_perms_owner_interact : public LLSelectedTEGetFunctor< bool >
  1673.     {
  1674. functor_getter_perms_owner_interact(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1675.         
  1676. bool get( LLViewerObject* object, S32 face )
  1677.         {
  1678.             if ( object )
  1679.                 if ( object->getTE(face) )
  1680.                     if ( object->getTE(face)->getMediaData() )
  1681.                         return (0 != (object->getTE(face)->getMediaData()->getPermsInteract() & LLMediaEntry::PERM_OWNER));
  1682.             return 0 != ( mMediaEntry.getPermsInteract() & LLMediaEntry::PERM_OWNER );
  1683.         };
  1685. const LLMediaEntry &mMediaEntry;
  1687.     } func_perms_owner_interact(default_media_data);
  1688.     identical = selected_objects->getSelectedTEValue( &func_perms_owner_interact, value_bool );
  1689.     base_key = std::string( LLPanelContents::PERMS_OWNER_INTERACT_KEY );
  1690.     mMediaSettings[ base_key ] = value_bool;
  1691.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1693.     // Perms - owner control
  1694.     value_bool = 0 != ( default_media_data.getPermsControl() & LLMediaEntry::PERM_OWNER );
  1695.     struct functor_getter_perms_owner_control : public LLSelectedTEGetFunctor< bool >
  1696.     {
  1697. functor_getter_perms_owner_control(const LLMediaEntry& entry) : mMediaEntry(entry) {}
  1698.         
  1699.         bool get( LLViewerObject* object, S32 face )
  1700.         {
  1701.             if ( object )
  1702.                 if ( object->getTE(face) )
  1703.                     if ( object->getTE(face)->getMediaData() )
  1704.                         return (0 != (object->getTE(face)->getMediaData()->getPermsControl() & LLMediaEntry::PERM_OWNER));
  1705.             return 0 != ( mMediaEntry.getPermsControl() & LLMediaEntry::PERM_OWNER );
  1706.         };
  1708. const LLMediaEntry &mMediaEntry;
  1710.     } func_perms_owner_control(default_media_data);
  1711.     identical = selected_objects ->getSelectedTEValue( &func_perms_owner_control, value_bool );
  1712.     base_key = std::string( LLPanelContents::PERMS_OWNER_CONTROL_KEY );
  1713.     mMediaSettings[ base_key ] = value_bool;
  1714.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1716.     // Perms - group interact
  1717.     value_bool = 0 != ( default_media_data.getPermsInteract() & LLMediaEntry::PERM_GROUP );
  1718.     struct functor_getter_perms_group_interact : public LLSelectedTEGetFunctor< bool >
  1719.     {
  1720. functor_getter_perms_group_interact(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1721.         
  1722.         bool get( LLViewerObject* object, S32 face )
  1723.         {
  1724.             if ( object )
  1725.                 if ( object->getTE(face) )
  1726.                     if ( object->getTE(face)->getMediaData() )
  1727.                         return (0 != (object->getTE(face)->getMediaData()->getPermsInteract() & LLMediaEntry::PERM_GROUP));
  1728.             return 0 != ( mMediaEntry.getPermsInteract() & LLMediaEntry::PERM_GROUP );
  1729.         };
  1731. const LLMediaEntry &mMediaEntry;
  1733.     } func_perms_group_interact(default_media_data);
  1734.     identical = selected_objects->getSelectedTEValue( &func_perms_group_interact, value_bool );
  1735.     base_key = std::string( LLPanelContents::PERMS_GROUP_INTERACT_KEY );
  1736.     mMediaSettings[ base_key ] = value_bool;
  1737.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1739.     // Perms - group control
  1740.     value_bool = 0 != ( default_media_data.getPermsControl() & LLMediaEntry::PERM_GROUP );
  1741.     struct functor_getter_perms_group_control : public LLSelectedTEGetFunctor< bool >
  1742.     {
  1743. functor_getter_perms_group_control(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1744.         
  1745.         bool get( LLViewerObject* object, S32 face )
  1746.         {
  1747.             if ( object )
  1748.                 if ( object->getTE(face) )
  1749.                     if ( object->getTE(face)->getMediaData() )
  1750.                         return (0 != (object->getTE(face)->getMediaData()->getPermsControl() & LLMediaEntry::PERM_GROUP));
  1751.             return 0 != ( mMediaEntry.getPermsControl() & LLMediaEntry::PERM_GROUP );
  1752.         };
  1754. const LLMediaEntry &mMediaEntry;
  1756.     } func_perms_group_control(default_media_data);
  1757.     identical = selected_objects->getSelectedTEValue( &func_perms_group_control, value_bool );
  1758.     base_key = std::string( LLPanelContents::PERMS_GROUP_CONTROL_KEY );
  1759.     mMediaSettings[ base_key ] = value_bool;
  1760.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1762.     // Perms - anyone interact
  1763.     value_bool = 0 != ( default_media_data.getPermsInteract() & LLMediaEntry::PERM_ANYONE );
  1764.     struct functor_getter_perms_anyone_interact : public LLSelectedTEGetFunctor< bool >
  1765.     {
  1766. functor_getter_perms_anyone_interact(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1767.         
  1768.         bool get( LLViewerObject* object, S32 face )
  1769.         {
  1770.             if ( object )
  1771.                 if ( object->getTE(face) )
  1772.                     if ( object->getTE(face)->getMediaData() )
  1773.                         return (0 != (object->getTE(face)->getMediaData()->getPermsInteract() & LLMediaEntry::PERM_ANYONE));
  1774.             return 0 != ( mMediaEntry.getPermsInteract() & LLMediaEntry::PERM_ANYONE );
  1775.         };
  1777. const LLMediaEntry &mMediaEntry;
  1779.     } func_perms_anyone_interact(default_media_data);
  1780.     identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func_perms_anyone_interact, value_bool );
  1781.     base_key = std::string( LLPanelContents::PERMS_ANYONE_INTERACT_KEY );
  1782.     mMediaSettings[ base_key ] = value_bool;
  1783.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1785.     // Perms - anyone control
  1786.     value_bool = 0 != ( default_media_data.getPermsControl() & LLMediaEntry::PERM_ANYONE );
  1787.     struct functor_getter_perms_anyone_control : public LLSelectedTEGetFunctor< bool >
  1788.     {
  1789. functor_getter_perms_anyone_control(const LLMediaEntry& entry) : mMediaEntry(entry) {}
  1790.         
  1791.         bool get( LLViewerObject* object, S32 face )
  1792.         {
  1793.             if ( object )
  1794.                 if ( object->getTE(face) )
  1795.                     if ( object->getTE(face)->getMediaData() )
  1796.                         return (0 != (object->getTE(face)->getMediaData()->getPermsControl() & LLMediaEntry::PERM_ANYONE));
  1797.             return 0 != ( mMediaEntry.getPermsControl() & LLMediaEntry::PERM_ANYONE );
  1798.         };
  1800. const LLMediaEntry &mMediaEntry;
  1802.     } func_perms_anyone_control(default_media_data);
  1803.     identical = selected_objects->getSelectedTEValue( &func_perms_anyone_control, value_bool );
  1804.     base_key = std::string( LLPanelContents::PERMS_ANYONE_CONTROL_KEY );
  1805.     mMediaSettings[ base_key ] = value_bool;
  1806.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1808.     // security - whitelist enable
  1809.     value_bool = default_media_data.getWhiteListEnable();
  1810.     struct functor_getter_whitelist_enable : public LLSelectedTEGetFunctor< bool >
  1811.     {
  1812. functor_getter_whitelist_enable(const LLMediaEntry& entry) : mMediaEntry(entry) {}
  1813.         
  1814.         bool get( LLViewerObject* object, S32 face )
  1815.         {
  1816.             if ( object )
  1817.                 if ( object->getTE(face) )
  1818.                     if ( object->getTE(face)->getMediaData() )
  1819.                         return object->getTE(face)->getMediaData()->getWhiteListEnable();
  1820.             return mMediaEntry.getWhiteListEnable();
  1821.         };
  1823. const LLMediaEntry &mMediaEntry;
  1825.     } func_whitelist_enable(default_media_data);
  1826.     identical = selected_objects->getSelectedTEValue( &func_whitelist_enable, value_bool );
  1827.     base_key = std::string( LLMediaEntry::WHITELIST_ENABLE_KEY );
  1828.     mMediaSettings[ base_key ] = value_bool;
  1829.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1831.     // security - whitelist URLs
  1832.     std::vector<std::string> value_vector_str = default_media_data.getWhiteList();
  1833.     struct functor_getter_whitelist_urls : public LLSelectedTEGetFunctor< std::vector<std::string> >
  1834.     {
  1835. functor_getter_whitelist_urls(const LLMediaEntry& entry): mMediaEntry(entry) {}
  1836.         
  1837.         std::vector<std::string> get( LLViewerObject* object, S32 face )
  1838.         {
  1839.             if ( object )
  1840.                 if ( object->getTE(face) )
  1841.                     if ( object->getTE(face)->getMediaData() )
  1842.                         return object->getTE(face)->getMediaData()->getWhiteList();
  1843.             return mMediaEntry.getWhiteList();
  1844.         };
  1846. const LLMediaEntry &mMediaEntry;
  1848.     } func_whitelist_urls(default_media_data);
  1849.     identical = selected_objects->getSelectedTEValue( &func_whitelist_urls, value_vector_str );
  1850.     base_key = std::string( LLMediaEntry::WHITELIST_KEY );
  1851. mMediaSettings[ base_key ].clear();
  1852.     std::vector< std::string >::iterator iter = value_vector_str.begin();
  1853.     while( iter != value_vector_str.end() )
  1854.     {
  1855.         std::string white_list_url = *iter;
  1856.         mMediaSettings[ base_key ].append( white_list_url );
  1857.         ++iter;
  1858.     };
  1860.     mMediaSettings[ base_key + std::string( LLPanelContents::TENTATIVE_SUFFIX ) ] = ! identical;
  1861. }