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

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

游戏引擎

开发平台：

C++ Builder

llfloaterscriptlimits.cpp：源码内容
  1. /** 
  2.  * @file llfloaterscriptlimits.cpp
  3.  * @author Gabriel Lee
  4.  * @brief Implementation of the region info and controls floater and panels.
  5.  *
  6.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2004-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #include "llviewerprecompiledheaders.h"
  35. #include "llfloaterscriptlimits.h"
  37. #include "llsdutil.h"
  38. #include "llsdutil_math.h"
  39. #include "message.h"
  41. #include "llagent.h"
  42. #include "llfloateravatarpicker.h"
  43. #include "llfloaterland.h"
  44. #include "llfloaterreg.h"
  45. #include "llregionhandle.h"
  46. #include "llscrolllistctrl.h"
  47. #include "llscrolllistitem.h"
  48. #include "llparcel.h"
  49. #include "lltabcontainer.h"
  50. #include "lltracker.h"
  51. #include "lltrans.h"
  52. #include "llviewercontrol.h"
  53. #include "lluictrlfactory.h"
  54. #include "llviewerparcelmgr.h"
  55. #include "llviewerregion.h"
  56. #include "llviewerwindow.h"
  58. ///----------------------------------------------------------------------------
  59. /// LLFloaterScriptLimits
  60. ///----------------------------------------------------------------------------
  62. // debug switches, won't work in release
  63. #ifndef LL_RELEASE_FOR_DOWNLOAD
  65. // dump responder replies to llinfos for debugging
  66. //#define DUMP_REPLIES_TO_LLINFOS
  68. #ifdef DUMP_REPLIES_TO_LLINFOS
  69. #include "llsdserialize.h"
  70. #include "llwindow.h"
  71. #endif
  73. // use fake LLSD responses to check the viewer side is working correctly
  74. // I'm syncing this with the server side efforts so hopfully we can keep
  75. // the to-ing and fro-ing between the two teams to a minimum
  76. //#define USE_FAKE_RESPONSES
  78. #ifdef USE_FAKE_RESPONSES
  79. const S32 FAKE_NUMBER_OF_URLS = 329;
  80. const S32 FAKE_AVAILABLE_URLS = 731;
  81. const S32 FAKE_AMOUNT_OF_MEMORY = 66741;
  82. const S32 FAKE_AVAILABLE_MEMORY = 895577;
  83. #endif
  85. #endif
  87. const S32 SIZE_OF_ONE_KB = 1024;
  89. LLFloaterScriptLimits::LLFloaterScriptLimits(const LLSD& seed)
  90. : LLFloater(seed)
  91. {
  92. }
  94. BOOL LLFloaterScriptLimits::postBuild()
  95. {
  96. // a little cheap and cheerful - if there's an about land panel open default to showing parcel info,
  97. // otherwise default to showing attachments (avatar appearance)
  98. bool selectParcelPanel = false;
  100. LLFloaterLand* instance = LLFloaterReg::getTypedInstance<LLFloaterLand>("about_land");
  101. if(instance)
  102. {
  103. if(instance->isShown())
  104. {
  105. selectParcelPanel = true;
  106. }
  107. }
  109. mTab = getChild<LLTabContainer>("scriptlimits_panels");
  111. if(!mTab)
  112. {
  113. llinfos << "Error! couldn't get scriptlimits_panels, aborting Script Information setup" << llendl;
  114. return FALSE;
  115. }
  117. // contruct the panels
  118. std::string land_url = gAgent.getRegion()->getCapability("LandResources");
  119. if (!land_url.empty())
  120. {
  121. LLPanelScriptLimitsRegionMemory* panel_memory;
  122. panel_memory = new LLPanelScriptLimitsRegionMemory;
  123. mInfoPanels.push_back(panel_memory);
  124. LLUICtrlFactory::getInstance()->buildPanel(panel_memory, "panel_script_limits_region_memory.xml");
  125. mTab->addTabPanel(panel_memory);
  126. }
  128. std::string attachment_url = gAgent.getRegion()->getCapability("AttachmentResources");
  129. if (!attachment_url.empty())
  130. {
  131. LLPanelScriptLimitsAttachment* panel_attachments = new LLPanelScriptLimitsAttachment;
  132. mInfoPanels.push_back(panel_attachments);
  133. LLUICtrlFactory::getInstance()->buildPanel(panel_attachments, "panel_script_limits_my_avatar.xml");
  134. mTab->addTabPanel(panel_attachments);
  135. }
  137. if(mInfoPanels.size() > 0)
  138. {
  139. mTab->selectTab(0);
  140. }
  142. if(!selectParcelPanel && (mInfoPanels.size() > 1))
  143. {
  144. mTab->selectTab(1);
  145. }
  147. return TRUE;
  148. }
  150. LLFloaterScriptLimits::~LLFloaterScriptLimits()
  151. {
  152. }
  154. // public
  155. void LLFloaterScriptLimits::refresh()
  156. {
  157. for(info_panels_t::iterator iter = mInfoPanels.begin();
  158. iter != mInfoPanels.end(); ++iter)
  159. {
  160. (*iter)->refresh();
  161. }
  162. }
  164. ///----------------------------------------------------------------------------
  165. // Base class for panels
  166. ///----------------------------------------------------------------------------
  168. LLPanelScriptLimitsInfo::LLPanelScriptLimitsInfo()
  169. : LLPanel()
  170. {
  171. }
  174. // virtual
  175. BOOL LLPanelScriptLimitsInfo::postBuild()
  176. {
  177. refresh();
  178. return TRUE;
  179. }
  181. // virtual 
  182. void LLPanelScriptLimitsInfo::updateChild(LLUICtrl* child_ctr)
  183. {
  184. }
  186. ///----------------------------------------------------------------------------
  187. // Responders
  188. ///----------------------------------------------------------------------------
  190. void fetchScriptLimitsRegionInfoResponder::result(const LLSD& content)
  191. {
  192. //we don't need to test with a fake respose here (shouldn't anyway)
  194. #ifdef DUMP_REPLIES_TO_LLINFOS
  196. LLSDNotationStreamer notation_streamer(content);
  197. std::ostringstream nice_llsd;
  198. nice_llsd << notation_streamer;
  200. OSMessageBox(nice_llsd.str(), "main cap response:", 0);
  202. llinfos << "main cap response:" << content << llendl;
  204. #endif
  206. // at this point we have an llsd which should contain ether one or two urls to the services we want.
  207. // first we look for the details service:
  208. if(content.has("ScriptResourceDetails"))
  209. {
  210. LLHTTPClient::get(content["ScriptResourceDetails"], new fetchScriptLimitsRegionDetailsResponder(mInfo));
  211. }
  212. else
  213. {
  214. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  215. if(!instance)
  216. {
  217. llinfos << "Failed to get llfloaterscriptlimits instance" << llendl;
  218. }
  219. }
  221. // then the summary service:
  222. if(content.has("ScriptResourceSummary"))
  223. {
  224. LLHTTPClient::get(content["ScriptResourceSummary"], new fetchScriptLimitsRegionSummaryResponder(mInfo));
  225. }
  226. }
  228. void fetchScriptLimitsRegionInfoResponder::error(U32 status, const std::string& reason)
  229. {
  230. llinfos << "Error from responder " << reason << llendl;
  231. }
  233. void fetchScriptLimitsRegionSummaryResponder::result(const LLSD& content_ref)
  234. {
  235. #ifdef USE_FAKE_RESPONSES
  237. LLSD fake_content;
  238. LLSD summary = LLSD::emptyMap();
  239. LLSD available = LLSD::emptyArray();
  240. LLSD available_urls = LLSD::emptyMap();
  241. LLSD available_memory = LLSD::emptyMap();
  242. LLSD used = LLSD::emptyArray();
  243. LLSD used_urls = LLSD::emptyMap();
  244. LLSD used_memory = LLSD::emptyMap();
  246. used_urls["type"] = "urls";
  247. used_urls["amount"] = FAKE_NUMBER_OF_URLS;
  248. available_urls["type"] = "urls";
  249. available_urls["amount"] = FAKE_AVAILABLE_URLS;
  250. used_memory["type"] = "memory";
  251. used_memory["amount"] = FAKE_AMOUNT_OF_MEMORY;
  252. available_memory["type"] = "memory";
  253. available_memory["amount"] = FAKE_AVAILABLE_MEMORY;
  255. //summary response:{'summary':{'available':[{'amount':i731,'type':'urls'},{'amount':i895577,'type':'memory'},{'amount':i731,'type':'urls'},{'amount':i895577,'type':'memory'}],'used':[{'amount':i329,'type':'urls'},{'amount':i66741,'type':'memory'}]}}
  257. used.append(used_urls);
  258. used.append(used_memory);
  259. available.append(available_urls);
  260. available.append(available_memory);
  262. summary["available"] = available;
  263. summary["used"] = used;
  265. fake_content["summary"] = summary;
  267. const LLSD& content = fake_content;
  269. #else
  271. const LLSD& content = content_ref;
  273. #endif
  276. #ifdef DUMP_REPLIES_TO_LLINFOS
  278. LLSDNotationStreamer notation_streamer(content);
  279. std::ostringstream nice_llsd;
  280. nice_llsd << notation_streamer;
  282. OSMessageBox(nice_llsd.str(), "summary response:", 0);
  284. llinfos << "summary response:" << *content << llendl;
  286. #endif
  288. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  289. if(!instance)
  290. {
  291. llinfos << "Failed to get llfloaterscriptlimits instance" << llendl;
  292. }
  293. else
  294. {
  295. LLTabContainer* tab = instance->getChild<LLTabContainer>("scriptlimits_panels");
  296. LLPanelScriptLimitsRegionMemory* panel_memory = (LLPanelScriptLimitsRegionMemory*)tab->getChild<LLPanel>("script_limits_region_memory_panel");
  297. panel_memory->setRegionSummary(content);
  298. }
  299. }
  301. void fetchScriptLimitsRegionSummaryResponder::error(U32 status, const std::string& reason)
  302. {
  303. llinfos << "Error from responder " << reason << llendl;
  304. }
  306. void fetchScriptLimitsRegionDetailsResponder::result(const LLSD& content_ref)
  307. {
  308. #ifdef USE_FAKE_RESPONSES
  309. /*
  310. Updated detail service, ** denotes field added:
  312. result (map)
  313. +-parcels (array of maps)
  314.   +-id (uuid)
  315.   +-local_id (S32)**
  316.   +-name (string)
  317.   +-owner_id (uuid) (in ERS as owner, but owner_id in code)
  318.   +-objects (array of maps)
  319.     +-id (uuid)
  320.     +-name (string)
  321. +-owner_id (uuid) (in ERS as owner, in code as owner_id)
  322. +-owner_name (sting)**
  323. +-location (map)**
  324.   +-x (float)
  325.   +-y (float)
  326.   +-z (float)
  327.     +-resources (map) (this is wrong in the ERS but right in code)
  328.       +-type (string)
  329.       +-amount (int)
  330. */
  331. LLSD fake_content;
  332. LLSD resource = LLSD::emptyMap();
  333. LLSD location = LLSD::emptyMap();
  334. LLSD object = LLSD::emptyMap();
  335. LLSD objects = LLSD::emptyArray();
  336. LLSD parcel = LLSD::emptyMap();
  337. LLSD parcels = LLSD::emptyArray();
  339. resource["urls"] = FAKE_NUMBER_OF_URLS;
  340. resource["memory"] = FAKE_AMOUNT_OF_MEMORY;
  342. location["x"] = 128.0f;
  343. location["y"] = 128.0f;
  344. location["z"] = 0.0f;
  346. object["id"] = LLUUID("d574a375-0c6c-fe3d-5733-da669465afc7");
  347. object["name"] = "Gabs fake Object!";
  348. object["owner_id"] = LLUUID("8dbf2d41-69a0-4e5e-9787-0c9d297bc570");
  349. object["owner_name"] = "Gabs Linden";
  350. object["location"] = location;
  351. object["resources"] = resource;
  353. objects.append(object);
  355. parcel["id"] = LLUUID("da05fb28-0d20-e593-2728-bddb42dd0160");
  356. parcel["local_id"] = 42;
  357. parcel["name"] = "Gabriel Linden's Sub Plot";
  358. parcel["objects"] = objects;
  359. parcels.append(parcel);
  361. fake_content["parcels"] = parcels;
  362. const LLSD& content = fake_content;
  364. #else
  366. const LLSD& content = content_ref;
  368. #endif
  370. #ifdef DUMP_REPLIES_TO_LLINFOS
  372. LLSDNotationStreamer notation_streamer(content);
  373. std::ostringstream nice_llsd;
  374. nice_llsd << notation_streamer;
  376. OSMessageBox(nice_llsd.str(), "details response:", 0);
  378. llinfos << "details response:" << content << llendl;
  380. #endif
  382. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  384. if(!instance)
  385. {
  386. llinfos << "Failed to get llfloaterscriptlimits instance" << llendl;
  387. }
  388. else
  389. {
  390. LLTabContainer* tab = instance->getChild<LLTabContainer>("scriptlimits_panels");
  391. if(tab)
  392. {
  393. LLPanelScriptLimitsRegionMemory* panel_memory = (LLPanelScriptLimitsRegionMemory*)tab->getChild<LLPanel>("script_limits_region_memory_panel");
  394. if(panel_memory)
  395. {
  396. panel_memory->setRegionDetails(content);
  397. }
  398. else
  399. {
  400. llinfos << "Failed to get scriptlimits memory panel" << llendl;
  401. }
  402. }
  403. else
  404. {
  405. llinfos << "Failed to get scriptlimits_panels" << llendl;
  406. }
  407. }
  408. }
  410. void fetchScriptLimitsRegionDetailsResponder::error(U32 status, const std::string& reason)
  411. {
  412. llinfos << "Error from responder " << reason << llendl;
  413. }
  415. void fetchScriptLimitsAttachmentInfoResponder::result(const LLSD& content_ref)
  416. {
  418. #ifdef USE_FAKE_RESPONSES
  420. // just add the summary, as that's all I'm testing currently!
  421. LLSD fake_content = LLSD::emptyMap();
  422. LLSD summary = LLSD::emptyMap();
  423. LLSD available = LLSD::emptyArray();
  424. LLSD available_urls = LLSD::emptyMap();
  425. LLSD available_memory = LLSD::emptyMap();
  426. LLSD used = LLSD::emptyArray();
  427. LLSD used_urls = LLSD::emptyMap();
  428. LLSD used_memory = LLSD::emptyMap();
  430. used_urls["type"] = "urls";
  431. used_urls["amount"] = FAKE_NUMBER_OF_URLS;
  432. available_urls["type"] = "urls";
  433. available_urls["amount"] = FAKE_AVAILABLE_URLS;
  434. used_memory["type"] = "memory";
  435. used_memory["amount"] = FAKE_AMOUNT_OF_MEMORY;
  436. available_memory["type"] = "memory";
  437. available_memory["amount"] = FAKE_AVAILABLE_MEMORY;
  439. used.append(used_urls);
  440. used.append(used_memory);
  441. available.append(available_urls);
  442. available.append(available_memory);
  444. summary["available"] = available;
  445. summary["used"] = used;
  447. fake_content["summary"] = summary;
  448. fake_content["attachments"] = content_ref["attachments"];
  450. const LLSD& content = fake_content;
  452. #else
  454. const LLSD& content = content_ref;
  456. #endif
  458. #ifdef DUMP_REPLIES_TO_LLINFOS
  460. LLSDNotationStreamer notation_streamer(content);
  461. std::ostringstream nice_llsd;
  462. nice_llsd << notation_streamer;
  464. OSMessageBox(nice_llsd.str(), "attachment response:", 0);
  466. llinfos << "attachment response:" << content << llendl;
  468. #endif
  470. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  472. if(!instance)
  473. {
  474. llinfos << "Failed to get llfloaterscriptlimits instance" << llendl;
  475. }
  476. else
  477. {
  478. LLTabContainer* tab = instance->getChild<LLTabContainer>("scriptlimits_panels");
  479. if(tab)
  480. {
  481. LLPanelScriptLimitsAttachment* panel = (LLPanelScriptLimitsAttachment*)tab->getChild<LLPanel>("script_limits_my_avatar_panel");
  482. if(panel)
  483. {
  484. panel->setAttachmentDetails(content);
  485. }
  486. else
  487. {
  488. llinfos << "Failed to get script_limits_my_avatar_panel" << llendl;
  489. }
  490. }
  491. else
  492. {
  493. llinfos << "Failed to get scriptlimits_panels" << llendl;
  494. }
  495. }
  496. }
  498. void fetchScriptLimitsAttachmentInfoResponder::error(U32 status, const std::string& reason)
  499. {
  500. llinfos << "Error from responder " << reason << llendl;
  501. }
  503. ///----------------------------------------------------------------------------
  504. // Memory Panel
  505. ///----------------------------------------------------------------------------
  507. BOOL LLPanelScriptLimitsRegionMemory::getLandScriptResources()
  508. {
  509. LLSD body;
  510. std::string url = gAgent.getRegion()->getCapability("LandResources");
  511. if (!url.empty())
  512. {
  513. body["parcel_id"] = mParcelId;
  515. LLSD info;
  516. info["parcel_id"] = mParcelId;
  517. LLHTTPClient::post(url, body, new fetchScriptLimitsRegionInfoResponder(info));
  519. return TRUE;
  520. }
  521. else
  522. {
  523. return FALSE;
  524. }
  525. }
  527. void LLPanelScriptLimitsRegionMemory::processParcelInfo(const LLParcelData& parcel_data)
  528. {
  529. mParcelId = parcel_data.parcel_id;
  531. if(!getLandScriptResources())
  532. {
  533. std::string msg_error = LLTrans::getString("ScriptLimitsRequestError");
  534. childSetValue("loading_text", LLSD(msg_error));
  535. }
  536. else
  537. {
  538. std::string msg_waiting = LLTrans::getString("ScriptLimitsRequestWaiting");
  539. childSetValue("loading_text", LLSD(msg_waiting));
  540. }
  541. }
  543. void LLPanelScriptLimitsRegionMemory::setParcelID(const LLUUID& parcel_id)
  544. {
  545. if (!parcel_id.isNull())
  546. {
  547. LLRemoteParcelInfoProcessor::getInstance()->addObserver(parcel_id, this);
  548. LLRemoteParcelInfoProcessor::getInstance()->sendParcelInfoRequest(parcel_id);
  549. }
  550. else
  551. {
  552. std::string msg_error = LLTrans::getString("ScriptLimitsRequestError");
  553. childSetValue("loading_text", LLSD(msg_error));
  554. }
  555. }
  557. // virtual
  558. void LLPanelScriptLimitsRegionMemory::setErrorStatus(U32 status, const std::string& reason)
  559. {
  560. llerrs << "Can't handle remote parcel request."<< " Http Status: "<< status << ". Reason : "<< reason<<llendl;
  561. }
  563. // callback from the name cache with an owner name to add to the list
  564. void LLPanelScriptLimitsRegionMemory::onNameCache(
  565.  const LLUUID& id,
  566.  const std::string& first_name,
  567.  const std::string& last_name)
  568. {
  569. std::string name = first_name + " " + last_name;
  571. LLScrollListCtrl *list = getChild<LLScrollListCtrl>("scripts_list");
  572. if(!list)
  573. {
  574. return;
  575. }
  577. std::vector<LLSD>::iterator id_itor;
  578. for (id_itor = mObjectListItems.begin(); id_itor != mObjectListItems.end(); ++id_itor)
  579. {
  580. LLSD element = *id_itor;
  581. if(element["owner_id"].asUUID() == id)
  582. {
  583. LLScrollListItem* item = list->getItem(element["id"].asUUID());
  585. if(item)
  586. {
  587. item->getColumn(3)->setValue(LLSD(name));
  588. element["columns"][3]["value"] = name;
  589. }
  590. }
  591. }
  592. }
  594. void LLPanelScriptLimitsRegionMemory::setRegionDetails(LLSD content)
  595. {
  596. LLScrollListCtrl *list = getChild<LLScrollListCtrl>("scripts_list");
  598. if(!list)
  599. {
  600. llinfos << "Error getting the scripts_list control" << llendl;
  601. return;
  602. }
  604. S32 number_parcels = content["parcels"].size();
  606. LLStringUtil::format_map_t args_parcels;
  607. args_parcels["[PARCELS]"] = llformat ("%d", number_parcels);
  608. std::string msg_parcels = LLTrans::getString("ScriptLimitsParcelsOwned", args_parcels);
  609. childSetValue("parcels_listed", LLSD(msg_parcels));
  611. std::vector<LLUUID> names_requested;
  613. // This makes the assumption that all objects will have the same set
  614. // of attributes, ie they will all have, or none will have locations
  615. // This is a pretty safe assumption as it's reliant on server version.
  616. bool has_locations = false;
  617. bool has_local_ids = false;
  619. for(S32 i = 0; i < number_parcels; i++)
  620. {
  621. std::string parcel_name = content["parcels"][i]["name"].asString();
  622. LLUUID parcel_id = content["parcels"][i]["id"].asUUID();
  623. S32 number_objects = content["parcels"][i]["objects"].size();
  625. S32 local_id = 0;
  626. if(content["parcels"][i].has("local_id"))
  627. {
  628. // if any locations are found flag that we can use them and turn on the highlight button
  629. has_local_ids = true;
  630. local_id = content["parcels"][i]["local_id"].asInteger();
  631. }
  633. for(S32 j = 0; j < number_objects; j++)
  634. {
  635. S32 size = content["parcels"][i]["objects"][j]["resources"]["memory"].asInteger() / SIZE_OF_ONE_KB;
  637. S32 urls = content["parcels"][i]["objects"][j]["resources"]["urls"].asInteger();
  639. std::string name_buf = content["parcels"][i]["objects"][j]["name"].asString();
  640. LLUUID task_id = content["parcels"][i]["objects"][j]["id"].asUUID();
  641. LLUUID owner_id = content["parcels"][i]["objects"][j]["owner_id"].asUUID();
  643. F32 location_x = 0.0f;
  644. F32 location_y = 0.0f;
  645. F32 location_z = 0.0f;
  647. if(content["parcels"][i]["objects"][j].has("location"))
  648. {
  649. // if any locations are found flag that we can use them and turn on the highlight button
  650. LLVector3 vec = ll_vector3_from_sd(content["parcels"][i]["objects"][j]["location"]);
  651. has_locations = true;
  652. location_x = vec.mV[0];
  653. location_y = vec.mV[1];
  654. location_z = vec.mV[2];
  655. }
  657. std::string owner_buf;
  659. // in the future the server will give us owner names, so see if we're there yet:
  660. if(content["parcels"][i]["objects"][j].has("owner_name"))
  661. {
  662. owner_buf = content["parcels"][i]["objects"][j]["owner_name"].asString();
  663. }
  664. // ...and if not use the slightly more painful method of disovery:
  665. else
  666. {
  667. BOOL name_is_cached = gCacheName->getFullName(owner_id, owner_buf);
  668. if(!name_is_cached)
  669. {
  670. if(std::find(names_requested.begin(), names_requested.end(), owner_id) == names_requested.end())
  671. {
  672. names_requested.push_back(owner_id);
  673. gCacheName->get(owner_id, TRUE,
  674. boost::bind(&LLPanelScriptLimitsRegionMemory::onNameCache,
  675. this, _1, _2, _3));
  676. }
  677. }
  678. }
  680. LLSD element;
  682. element["id"] = task_id;
  683. element["columns"][0]["column"] = "size";
  684. element["columns"][0]["value"] = llformat("%d", size);
  685. element["columns"][0]["font"] = "SANSSERIF";
  686. element["columns"][1]["column"] = "urls";
  687. element["columns"][1]["value"] = llformat("%d", urls);
  688. element["columns"][1]["font"] = "SANSSERIF";
  689. element["columns"][2]["column"] = "name";
  690. element["columns"][2]["value"] = name_buf;
  691. element["columns"][2]["font"] = "SANSSERIF";
  692. element["columns"][3]["column"] = "owner";
  693. element["columns"][3]["value"] = owner_buf;
  694. element["columns"][3]["font"] = "SANSSERIF";
  695. element["columns"][4]["column"] = "parcel";
  696. element["columns"][4]["value"] = parcel_name;
  697. element["columns"][4]["font"] = "SANSSERIF";
  698. element["columns"][5]["column"] = "location";
  699. if(has_locations)
  700. {
  701. element["columns"][5]["value"] = llformat("<%0.1f,%0.1f,%0.1f>", location_x, location_y, location_z);
  702. }
  703. else
  704. {
  705. element["columns"][5]["value"] = "";
  706. }
  707. element["columns"][5]["font"] = "SANSSERIF";
  709. list->addElement(element, ADD_SORTED);
  711. element["owner_id"] = owner_id;
  712. element["local_id"] = local_id;
  713. mObjectListItems.push_back(element);
  714. }
  715. }
  717. if (has_locations)
  718. {
  719. LLButton* btn = getChild<LLButton>("highlight_btn");
  720. if(btn)
  721. {
  722. btn->setVisible(true);
  723. }
  724. }
  726. if (has_local_ids)
  727. {
  728. LLButton* btn = getChild<LLButton>("return_btn");
  729. if(btn)
  730. {
  731. btn->setVisible(true);
  732. }
  733. }
  735. // save the structure to make object return easier
  736. mContent = content;
  738. childSetValue("loading_text", LLSD(std::string("")));
  739. }
  741. void LLPanelScriptLimitsRegionMemory::setRegionSummary(LLSD content)
  742. {
  743. if(content["summary"]["used"][0]["type"].asString() == std::string("memory"))
  744. {
  745. mParcelMemoryUsed = content["summary"]["used"][0]["amount"].asInteger() / SIZE_OF_ONE_KB;
  746. mParcelMemoryMax = content["summary"]["available"][0]["amount"].asInteger() / SIZE_OF_ONE_KB;
  747. mGotParcelMemoryUsed = true;
  748. }
  749. else if(content["summary"]["used"][1]["type"].asString() == std::string("memory"))
  750. {
  751. mParcelMemoryUsed = content["summary"]["used"][1]["amount"].asInteger() / SIZE_OF_ONE_KB;
  752. mParcelMemoryMax = content["summary"]["available"][1]["amount"].asInteger() / SIZE_OF_ONE_KB;
  753. mGotParcelMemoryUsed = true;
  754. }
  755. else
  756. {
  757. llinfos << "summary doesn't contain memory info" << llendl;
  758. return;
  759. }
  761. if(content["summary"]["used"][0]["type"].asString() == std::string("urls"))
  762. {
  763. mParcelURLsUsed = content["summary"]["used"][0]["amount"].asInteger();
  764. mParcelURLsMax = content["summary"]["available"][0]["amount"].asInteger();
  765. mGotParcelURLsUsed = true;
  766. }
  767. else if(content["summary"]["used"][1]["type"].asString() == std::string("urls"))
  768. {
  769. mParcelURLsUsed = content["summary"]["used"][1]["amount"].asInteger();
  770. mParcelURLsMax = content["summary"]["available"][1]["amount"].asInteger();
  771. mGotParcelURLsUsed = true;
  772. }
  773. else
  774. {
  775. llinfos << "summary doesn't contain urls info" << llendl;
  776. return;
  777. }
  779. if((mParcelMemoryUsed >= 0) && (mParcelMemoryMax >= 0))
  780. {
  781. S32 parcel_memory_available = mParcelMemoryMax - mParcelMemoryUsed;
  783. LLStringUtil::format_map_t args_parcel_memory;
  784. args_parcel_memory["[COUNT]"] = llformat ("%d", mParcelMemoryUsed);
  785. args_parcel_memory["[MAX]"] = llformat ("%d", mParcelMemoryMax);
  786. args_parcel_memory["[AVAILABLE]"] = llformat ("%d", parcel_memory_available);
  787. std::string msg_parcel_memory = LLTrans::getString("ScriptLimitsMemoryUsed", args_parcel_memory);
  788. childSetValue("memory_used", LLSD(msg_parcel_memory));
  789. }
  791. if((mParcelURLsUsed >= 0) && (mParcelURLsMax >= 0))
  792. {
  793. S32 parcel_urls_available = mParcelURLsMax - mParcelURLsUsed;
  795. LLStringUtil::format_map_t args_parcel_urls;
  796. args_parcel_urls["[COUNT]"] = llformat ("%d", mParcelURLsUsed);
  797. args_parcel_urls["[MAX]"] = llformat ("%d", mParcelURLsMax);
  798. args_parcel_urls["[AVAILABLE]"] = llformat ("%d", parcel_urls_available);
  799. std::string msg_parcel_urls = LLTrans::getString("ScriptLimitsURLsUsed", args_parcel_urls);
  800. childSetValue("urls_used", LLSD(msg_parcel_urls));
  801. }
  802. }
  804. BOOL LLPanelScriptLimitsRegionMemory::postBuild()
  805. {
  806. childSetAction("refresh_list_btn", onClickRefresh, this);
  807. childSetAction("highlight_btn", onClickHighlight, this);
  808. childSetAction("return_btn", onClickReturn, this);
  810. std::string msg_waiting = LLTrans::getString("ScriptLimitsRequestWaiting");
  811. childSetValue("loading_text", LLSD(msg_waiting));
  813. LLScrollListCtrl *list = getChild<LLScrollListCtrl>("scripts_list");
  814. if(!list)
  815. {
  816. return FALSE;
  817. }
  819. //set all columns to resizable mode even if some columns will be empty
  820. for(S32 column = 0; column < list->getNumColumns(); column++)
  821. {
  822. LLScrollListColumn* columnp = list->getColumn(column);
  823. columnp->mHeader->setHasResizableElement(TRUE);
  824. }
  826. return StartRequestChain();
  827. }
  829. BOOL LLPanelScriptLimitsRegionMemory::StartRequestChain()
  830. {
  831. LLUUID region_id;
  833. LLFloaterLand* instance = LLFloaterReg::getTypedInstance<LLFloaterLand>("about_land");
  834. if(!instance)
  835. {
  836. childSetValue("loading_text", LLSD(std::string("")));
  837. //might have to do parent post build here
  838. //if not logic below could use early outs
  839. return FALSE;
  840. }
  841. LLParcel* parcel = instance->getCurrentSelectedParcel();
  842. LLViewerRegion* region = LLViewerParcelMgr::getInstance()->getSelectionRegion();
  844. LLUUID current_region_id = gAgent.getRegion()->getRegionID();
  846. if ((region) && (parcel))
  847. {
  848. LLVector3 parcel_center = parcel->getCenterpoint();
  850. region_id = region->getRegionID();
  852. if(region_id != current_region_id)
  853. {
  854. std::string msg_wrong_region = LLTrans::getString("ScriptLimitsRequestWrongRegion");
  855. childSetValue("loading_text", LLSD(msg_wrong_region));
  856. return FALSE;
  857. }
  859. LLVector3d pos_global = region->getCenterGlobal();
  861. LLSD body;
  862. std::string url = region->getCapability("RemoteParcelRequest");
  863. if (!url.empty())
  864. {
  865. body["location"] = ll_sd_from_vector3(parcel_center);
  866. if (!region_id.isNull())
  867. {
  868. body["region_id"] = region_id;
  869. }
  870. if (!pos_global.isExactlyZero())
  871. {
  872. U64 region_handle = to_region_handle(pos_global);
  873. body["region_handle"] = ll_sd_from_U64(region_handle);
  874. }
  875. LLHTTPClient::post(url, body, new LLRemoteParcelRequestResponder(getObserverHandle()));
  876. }
  877. else
  878. {
  879. llwarns << "Can't get parcel info for script information request" << region_id
  880. << ". Region: " << region->getName()
  881. << " does not support RemoteParcelRequest" << llendl;
  883. std::string msg_waiting = LLTrans::getString("ScriptLimitsRequestError");
  884. childSetValue("loading_text", LLSD(msg_waiting));
  885. }
  886. }
  887. else
  888. {
  889. std::string msg_waiting = LLTrans::getString("ScriptLimitsRequestNoParcelSelected");
  890. childSetValue("loading_text", LLSD(msg_waiting));
  891. }
  893. return LLPanelScriptLimitsInfo::postBuild();
  894. }
  896. void LLPanelScriptLimitsRegionMemory::clearList()
  897. {
  898. LLCtrlListInterface *list = childGetListInterface("scripts_list");
  900. if (list)
  901. {
  902. list->operateOnAll(LLCtrlListInterface::OP_DELETE);
  903. }
  905. mGotParcelMemoryUsed = false;
  906. mGotParcelMemoryMax = false;
  907. mGotParcelURLsUsed = false;
  908. mGotParcelURLsMax = false;
  910. LLStringUtil::format_map_t args_parcel_memory;
  911. std::string msg_empty_string("");
  912. childSetValue("memory_used", LLSD(msg_empty_string));
  913. childSetValue("urls_used", LLSD(msg_empty_string));
  914. childSetValue("parcels_listed", LLSD(msg_empty_string));
  916. mObjectListItems.clear();
  917. }
  919. // static
  920. void LLPanelScriptLimitsRegionMemory::onClickRefresh(void* userdata)
  921. {
  922. llinfos << "LLPanelRegionGeneralInfo::onClickRefresh" << llendl;
  924. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  925. if(instance)
  926. {
  927. LLTabContainer* tab = instance->getChild<LLTabContainer>("scriptlimits_panels");
  928. if(tab)
  929. {
  930. LLPanelScriptLimitsRegionMemory* panel_memory = (LLPanelScriptLimitsRegionMemory*)tab->getChild<LLPanel>("script_limits_region_memory_panel");
  931. if(panel_memory)
  932. {
  933. panel_memory->clearList();
  935. panel_memory->StartRequestChain();
  936. }
  937. }
  938. return;
  939. }
  940. else
  941. {
  942. llwarns << "could not find LLPanelScriptLimitsRegionMemory instance after refresh button clicked" << llendl;
  943. return;
  944. }
  945. }
  947. void LLPanelScriptLimitsRegionMemory::showBeacon()
  948. {
  949. LLScrollListCtrl* list = getChild<LLScrollListCtrl>("scripts_list");
  950. if (!list) return;
  952. LLScrollListItem* first_selected = list->getFirstSelected();
  953. if (!first_selected) return;
  955. std::string name = first_selected->getColumn(2)->getValue().asString();
  956. std::string pos_string =  first_selected->getColumn(5)->getValue().asString();
  958. F32 x, y, z;
  959. S32 matched = sscanf(pos_string.c_str(), "<%g,%g,%g>", &x, &y, &z);
  960. if (matched != 3) return;
  962. LLVector3 pos_agent(x, y, z);
  963. LLVector3d pos_global = gAgent.getPosGlobalFromAgent(pos_agent);
  965. std::string tooltip("");
  966. LLTracker::trackLocation(pos_global, name, tooltip, LLTracker::LOCATION_ITEM);
  967. }
  969. // static
  970. void LLPanelScriptLimitsRegionMemory::onClickHighlight(void* userdata)
  971. {
  972. llinfos << "LLPanelRegionGeneralInfo::onClickHighlight" << llendl;
  973. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  974. if(instance)
  975. {
  976. LLTabContainer* tab = instance->getChild<LLTabContainer>("scriptlimits_panels");
  977. if(tab)
  978. {
  979. LLPanelScriptLimitsRegionMemory* panel = (LLPanelScriptLimitsRegionMemory*)tab->getChild<LLPanel>("script_limits_region_memory_panel");
  980. if(panel)
  981. {
  982. panel->showBeacon();
  983. }
  984. }
  985. return;
  986. }
  987. else
  988. {
  989. llwarns << "could not find LLPanelScriptLimitsRegionMemory instance after highlight button clicked" << llendl;
  990. return;
  991. }
  992. }
  994. void LLPanelScriptLimitsRegionMemory::returnObjectsFromParcel(S32 local_id)
  995. {
  996. LLMessageSystem *msg = gMessageSystem;
  998. LLViewerRegion* region = gAgent.getRegion();
  999. if (!region) return;
  1001. LLCtrlListInterface *list = childGetListInterface("scripts_list");
  1002. if (!list || list->getItemCount() == 0) return;
  1004. std::vector<LLSD>::iterator id_itor;
  1006. bool start_message = true;
  1008. for (id_itor = mObjectListItems.begin(); id_itor != mObjectListItems.end(); ++id_itor)
  1009. {
  1010. LLSD element = *id_itor;
  1011. if (!list->isSelected(element["id"].asUUID()))
  1012. {
  1013. // Selected only
  1014. continue;
  1015. }
  1017. if(element["local_id"].asInteger() != local_id)
  1018. {
  1019. // Not the parcel we are looking for
  1020. continue;
  1021. }
  1023. if (start_message)
  1024. {
  1025. msg->newMessageFast(_PREHASH_ParcelReturnObjects);
  1026. msg->nextBlockFast(_PREHASH_AgentData);
  1027. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1028. msg->addUUIDFast(_PREHASH_SessionID,gAgent.getSessionID());
  1029. msg->nextBlockFast(_PREHASH_ParcelData);
  1030. msg->addS32Fast(_PREHASH_LocalID, element["local_id"].asInteger());
  1031. msg->addU32Fast(_PREHASH_ReturnType, RT_LIST);
  1032. start_message = false;
  1033. }
  1035. msg->nextBlockFast(_PREHASH_TaskIDs);
  1036. msg->addUUIDFast(_PREHASH_TaskID, element["id"].asUUID());
  1038. if (msg->isSendFullFast(_PREHASH_TaskIDs))
  1039. {
  1040. msg->sendReliable(region->getHost());
  1041. start_message = true;
  1042. }
  1043. }
  1045. if (!start_message)
  1046. {
  1047. msg->sendReliable(region->getHost());
  1048. }
  1049. }
  1051. void LLPanelScriptLimitsRegionMemory::returnObjects()
  1052. {
  1053. if(!mContent.has("parcels"))
  1054. {
  1055. return;
  1056. }
  1058. S32 number_parcels = mContent["parcels"].size();
  1060. // a message per parcel containing all objects to be returned from that parcel
  1061. for(S32 i = 0; i < number_parcels; i++)
  1062. {
  1063. S32 local_id = 0;
  1064. if(mContent["parcels"][i].has("local_id"))
  1065. {
  1066. local_id = mContent["parcels"][i]["local_id"].asInteger();
  1067. returnObjectsFromParcel(local_id);
  1068. }
  1069. }
  1071. onClickRefresh(NULL);
  1072. }
  1075. // static
  1076. void LLPanelScriptLimitsRegionMemory::onClickReturn(void* userdata)
  1077. {
  1078. llinfos << "LLPanelRegionGeneralInfo::onClickReturn" << llendl;
  1079. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  1080. if(instance)
  1081. {
  1082. LLTabContainer* tab = instance->getChild<LLTabContainer>("scriptlimits_panels");
  1083. if(tab)
  1084. {
  1085. LLPanelScriptLimitsRegionMemory* panel = (LLPanelScriptLimitsRegionMemory*)tab->getChild<LLPanel>("script_limits_region_memory_panel");
  1086. if(panel)
  1087. {
  1088. panel->returnObjects();
  1089. }
  1090. }
  1091. return;
  1092. }
  1093. else
  1094. {
  1095. llwarns << "could not find LLPanelScriptLimitsRegionMemory instance after highlight button clicked" << llendl;
  1096. return;
  1097. }
  1098. }
  1100. ///----------------------------------------------------------------------------
  1101. // Attachment Panel
  1102. ///----------------------------------------------------------------------------
  1104. BOOL LLPanelScriptLimitsAttachment::requestAttachmentDetails()
  1105. {
  1106. LLSD body;
  1107. std::string url = gAgent.getRegion()->getCapability("AttachmentResources");
  1108. if (!url.empty())
  1109. {
  1110. LLHTTPClient::get(url, body, new fetchScriptLimitsAttachmentInfoResponder());
  1111. return TRUE;
  1112. }
  1113. else
  1114. {
  1115. return FALSE;
  1116. }
  1117. }
  1119. void LLPanelScriptLimitsAttachment::setAttachmentDetails(LLSD content)
  1120. {
  1121. LLScrollListCtrl *list = getChild<LLScrollListCtrl>("scripts_list");
  1123. if(!list)
  1124. {
  1125. return;
  1126. }
  1128. S32 number_attachments = content["attachments"].size();
  1130. for(int i = 0; i < number_attachments; i++)
  1131. {
  1132. std::string humanReadableLocation = "";
  1133. if(content["attachments"][i].has("location"))
  1134. {
  1135. std::string actualLocation = content["attachments"][i]["location"];
  1136. humanReadableLocation = LLTrans::getString(actualLocation.c_str());
  1137. }
  1139. S32 number_objects = content["attachments"][i]["objects"].size();
  1140. for(int j = 0; j < number_objects; j++)
  1141. {
  1142. LLUUID task_id = content["attachments"][i]["objects"][j]["id"].asUUID();
  1143. S32 size = 0;
  1144. if(content["attachments"][i]["objects"][j]["resources"].has("memory"))
  1145. {
  1146. size = content["attachments"][i]["objects"][j]["resources"]["memory"].asInteger() / SIZE_OF_ONE_KB;
  1147. }
  1148. S32 urls = 0;
  1149. if(content["attachments"][i]["objects"][j]["resources"].has("urls"))
  1150. {
  1151. urls = content["attachments"][i]["objects"][j]["resources"]["urls"].asInteger();
  1152. }
  1153. std::string name = content["attachments"][i]["objects"][j]["name"].asString();
  1155. LLSD element;
  1157. element["id"] = task_id;
  1158. element["columns"][0]["column"] = "size";
  1159. element["columns"][0]["value"] = llformat("%d", size);
  1160. element["columns"][0]["font"] = "SANSSERIF";
  1162. element["columns"][1]["column"] = "urls";
  1163. element["columns"][1]["value"] = llformat("%d", urls);
  1164. element["columns"][1]["font"] = "SANSSERIF";
  1166. element["columns"][2]["column"] = "name";
  1167. element["columns"][2]["value"] = name;
  1168. element["columns"][2]["font"] = "SANSSERIF";
  1170. element["columns"][3]["column"] = "location";
  1171. element["columns"][3]["value"] = humanReadableLocation;
  1172. element["columns"][3]["font"] = "SANSSERIF";
  1174. list->addElement(element);
  1175. }
  1176. }
  1178. setAttachmentSummary(content);
  1180. childSetValue("loading_text", LLSD(std::string("")));
  1181. }
  1183. BOOL LLPanelScriptLimitsAttachment::postBuild()
  1184. {
  1185. childSetAction("refresh_list_btn", onClickRefresh, this);
  1187. std::string msg_waiting = LLTrans::getString("ScriptLimitsRequestWaiting");
  1188. childSetValue("loading_text", LLSD(msg_waiting));
  1189. return requestAttachmentDetails();
  1190. }
  1192. void LLPanelScriptLimitsAttachment::clearList()
  1193. {
  1194. LLCtrlListInterface *list = childGetListInterface("scripts_list");
  1196. if (list)
  1197. {
  1198. list->operateOnAll(LLCtrlListInterface::OP_DELETE);
  1199. }
  1201. std::string msg_waiting = LLTrans::getString("ScriptLimitsRequestWaiting");
  1202. childSetValue("loading_text", LLSD(msg_waiting));
  1203. }
  1205. void LLPanelScriptLimitsAttachment::setAttachmentSummary(LLSD content)
  1206. {
  1207. if(content["summary"]["used"][0]["type"].asString() == std::string("memory"))
  1208. {
  1209. mAttachmentMemoryUsed = content["summary"]["used"][0]["amount"].asInteger() / SIZE_OF_ONE_KB;
  1210. mAttachmentMemoryMax = content["summary"]["available"][0]["amount"].asInteger() / SIZE_OF_ONE_KB;
  1211. mGotAttachmentMemoryUsed = true;
  1212. }
  1213. else if(content["summary"]["used"][1]["type"].asString() == std::string("memory"))
  1214. {
  1215. mAttachmentMemoryUsed = content["summary"]["used"][1]["amount"].asInteger() / SIZE_OF_ONE_KB;
  1216. mAttachmentMemoryMax = content["summary"]["available"][1]["amount"].asInteger() / SIZE_OF_ONE_KB;
  1217. mGotAttachmentMemoryUsed = true;
  1218. }
  1219. else
  1220. {
  1221. llinfos << "attachment details don't contain memory summary info" << llendl;
  1222. return;
  1223. }
  1225. if(content["summary"]["used"][0]["type"].asString() == std::string("urls"))
  1226. {
  1227. mAttachmentURLsUsed = content["summary"]["used"][0]["amount"].asInteger();
  1228. mAttachmentURLsMax = content["summary"]["available"][0]["amount"].asInteger();
  1229. mGotAttachmentURLsUsed = true;
  1230. }
  1231. else if(content["summary"]["used"][1]["type"].asString() == std::string("urls"))
  1232. {
  1233. mAttachmentURLsUsed = content["summary"]["used"][1]["amount"].asInteger();
  1234. mAttachmentURLsMax = content["summary"]["available"][1]["amount"].asInteger();
  1235. mGotAttachmentURLsUsed = true;
  1236. }
  1237. else
  1238. {
  1239. llinfos << "attachment details don't contain urls summary info" << llendl;
  1240. return;
  1241. }
  1243. if((mAttachmentMemoryUsed >= 0) && (mAttachmentMemoryMax >= 0))
  1244. {
  1245. S32 attachment_memory_available = mAttachmentMemoryMax - mAttachmentMemoryUsed;
  1247. LLStringUtil::format_map_t args_attachment_memory;
  1248. args_attachment_memory["[COUNT]"] = llformat ("%d", mAttachmentMemoryUsed);
  1249. args_attachment_memory["[MAX]"] = llformat ("%d", mAttachmentMemoryMax);
  1250. args_attachment_memory["[AVAILABLE]"] = llformat ("%d", attachment_memory_available);
  1251. std::string msg_attachment_memory = LLTrans::getString("ScriptLimitsMemoryUsed", args_attachment_memory);
  1252. childSetValue("memory_used", LLSD(msg_attachment_memory));
  1253. }
  1255. if((mAttachmentURLsUsed >= 0) && (mAttachmentURLsMax >= 0))
  1256. {
  1257. S32 attachment_urls_available = mAttachmentURLsMax - mAttachmentURLsUsed;
  1259. LLStringUtil::format_map_t args_attachment_urls;
  1260. args_attachment_urls["[COUNT]"] = llformat ("%d", mAttachmentURLsUsed);
  1261. args_attachment_urls["[MAX]"] = llformat ("%d", mAttachmentURLsMax);
  1262. args_attachment_urls["[AVAILABLE]"] = llformat ("%d", attachment_urls_available);
  1263. std::string msg_attachment_urls = LLTrans::getString("ScriptLimitsURLsUsed", args_attachment_urls);
  1264. childSetValue("urls_used", LLSD(msg_attachment_urls));
  1265. }
  1266. }
  1268. // static
  1269. void LLPanelScriptLimitsAttachment::onClickRefresh(void* userdata)
  1270. {
  1271. llinfos << "Refresh clicked" << llendl;
  1273. LLFloaterScriptLimits* instance = LLFloaterReg::getTypedInstance<LLFloaterScriptLimits>("script_limits");
  1274. if(instance)
  1275. {
  1276. LLTabContainer* tab = instance->getChild<LLTabContainer>("scriptlimits_panels");
  1277. LLPanelScriptLimitsAttachment* panel_attachments = (LLPanelScriptLimitsAttachment*)tab->getChild<LLPanel>("script_limits_my_avatar_panel");
  1278. panel_attachments->clearList();
  1279. panel_attachments->requestAttachmentDetails();
  1280. return;
  1281. }
  1282. else
  1283. {
  1284. llwarns << "could not find LLPanelScriptLimitsRegionMemory instance after refresh button clicked" << llendl;
  1285. return;
  1286. }
  1287. }