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

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

游戏引擎

开发平台：

C++ Builder

llcompilequeue.cpp：源码内容
  1. /** 
  2.  * @file llcompilequeue.cpp
  3.  * @brief LLCompileQueueData class implementation
  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. /**
  34.  *
  35.  * Implementation of the script queue which keeps an array of object
  36.  * UUIDs and manipulates all of the scripts on each of them. 
  37.  *
  38.  */
  41. #include "llviewerprecompiledheaders.h"
  43. #include "llcompilequeue.h"
  45. #include "llagent.h"
  46. #include "llassetuploadqueue.h"
  47. #include "llassetuploadresponders.h"
  48. #include "llchat.h"
  49. #include "llfloaterreg.h"
  50. #include "llviewerwindow.h"
  51. #include "llviewerobject.h"
  52. #include "llviewerobjectlist.h"
  53. #include "llviewerregion.h"
  54. #include "lscript_rt_interface.h"
  55. #include "llviewercontrol.h"
  56. #include "llviewerobject.h"
  57. #include "llviewerregion.h"
  58. #include "llresmgr.h"
  60. #include "llbutton.h"
  61. #include "lldir.h"
  62. #include "llnotificationsutil.h"
  63. #include "llviewerstats.h"
  64. #include "llvfile.h"
  65. #include "lluictrlfactory.h"
  66. #include "lltrans.h"
  68. #include "llselectmgr.h"
  70. // *TODO: This should be separated into the script queue, and the floater views of that queue.
  71. // There should only be one floater class that can view any queue type
  73. ///----------------------------------------------------------------------------
  74. /// Local function declarations, constants, enums, and typedefs
  75. ///----------------------------------------------------------------------------
  77. struct LLScriptQueueData
  78. {
  79. LLUUID mQueueID;
  80. std::string mScriptName;
  81. LLUUID mTaskId;
  82. LLUUID mItemId;
  83. LLScriptQueueData(const LLUUID& q_id, const std::string& name, const LLUUID& task_id, const LLUUID& item_id) :
  84. mQueueID(q_id), mScriptName(name), mTaskId(task_id), mItemId(item_id) {}
  86. };
  88. ///----------------------------------------------------------------------------
  89. /// Class LLFloaterScriptQueue
  90. ///----------------------------------------------------------------------------
  92. // Default constructor
  93. LLFloaterScriptQueue::LLFloaterScriptQueue(const LLSD& key) :
  94. LLFloater(key),
  95. mDone(false),
  96. mMono(false)
  97. {
  98. //Called from floater reg: LLUICtrlFactory::getInstance()->buildFloater(this,"floater_script_queue.xml", FALSE);
  99. }
  101. // Destroys the object
  102. LLFloaterScriptQueue::~LLFloaterScriptQueue()
  103. {
  104. }
  106. BOOL LLFloaterScriptQueue::postBuild()
  107. {
  108. childSetAction("close",onCloseBtn,this);
  109. childSetEnabled("close",FALSE);
  110. return TRUE;
  111. }
  113. // This is the callback method for the viewer object currently being
  114. // worked on.
  115. // NOT static, virtual!
  116. void LLFloaterScriptQueue::inventoryChanged(LLViewerObject* viewer_object,
  117.  InventoryObjectList* inv,
  118.  S32,
  119.  void* q_id)
  120. {
  121. llinfos << "LLFloaterScriptQueue::inventoryChanged() for  object "
  122. << viewer_object->getID() << llendl;
  124. //Remove this listener from the object since its
  125. //listener callback is now being executed.
  127. //We remove the listener here because the function
  128. //removeVOInventoryListener removes the listener from a ViewerObject
  129. //which it internally stores.
  131. //If we call this further down in the function, calls to handleInventory
  132. //and nextObject may update the interally stored viewer object causing
  133. //the removal of the incorrect listener from an incorrect object.
  135. //Fixes SL-6119:Recompile scripts fails to complete
  136. removeVOInventoryListener();
  138. if (viewer_object && inv && (viewer_object->getID() == mCurrentObjectID) )
  139. {
  140. handleInventory(viewer_object, inv);
  141. }
  142. else
  143. {
  144. // something went wrong...
  145. // note that we're not working on this one, and move onto the
  146. // next object in the list.
  147. llwarns << "No inventory for " << mCurrentObjectID
  148. << llendl;
  149. nextObject();
  150. }
  151. }
  154. // static
  155. void LLFloaterScriptQueue::onCloseBtn(void* user_data)
  156. {
  157. LLFloaterScriptQueue* self = (LLFloaterScriptQueue*)user_data;
  158. self->closeFloater();
  159. }
  161. void LLFloaterScriptQueue::addObject(const LLUUID& id)
  162. {
  163. mObjectIDs.put(id);
  164. }
  166. BOOL LLFloaterScriptQueue::start()
  167. {
  168. //llinfos << "LLFloaterCompileQueue::start()" << llendl;
  169. std::string buffer;
  171. LLSelectMgr *mgr = LLSelectMgr::getInstance();
  172. LLObjectSelectionHandle selectHandle = mgr->getSelection();
  173. U32 n_objects = 0;
  174. if (gSavedSettings.getBOOL("EditLinkedParts"))
  175. {
  176. n_objects = selectHandle->getObjectCount();
  177. }
  178. else
  179. {
  180. n_objects = selectHandle->getRootObjectCount();
  181. }
  183. LLStringUtil::format_map_t args;
  184. args["[START]"] = mStartString;
  185. args["[COUNT]"] = llformat ("%d", mObjectIDs.count());
  186. buffer = getString ("Starting", args);
  188. getChild<LLScrollListCtrl>("queue output")->setCommentText(buffer);
  190. return nextObject();
  191. }
  193. BOOL LLFloaterScriptQueue::isDone() const
  194. {
  195. return (mCurrentObjectID.isNull() && (mObjectIDs.count() == 0));
  196. }
  198. // go to the next object. If no objects left, it falls out silently
  199. // and waits to be killed by the window being closed.
  200. BOOL LLFloaterScriptQueue::nextObject()
  201. {
  202. S32 count;
  203. BOOL successful_start = FALSE;
  204. do
  205. {
  206. count = mObjectIDs.count();
  207. llinfos << "LLFloaterScriptQueue::nextObject() - " << count
  208. << " objects left to process." << llendl;
  209. mCurrentObjectID.setNull();
  210. if(count > 0)
  211. {
  212. successful_start = popNext();
  213. }
  214. llinfos << "LLFloaterScriptQueue::nextObject() "
  215. << (successful_start ? "successful" : "unsuccessful")
  216. << llendl; 
  217. } while((mObjectIDs.count() > 0) && !successful_start);
  218. if(isDone() && !mDone)
  219. {
  220. mDone = true;
  221. getChild<LLScrollListCtrl>("queue output")->setCommentText(getString("Done"));
  222. childSetEnabled("close",TRUE);
  223. }
  224. return successful_start;
  225. }
  227. // returns true if the queue has started, otherwise false.  This
  228. // method pops the top object off of the queue.
  229. BOOL LLFloaterScriptQueue::popNext()
  230. {
  231. // get the first element off of the container, and attempt to get
  232. // the inventory.
  233. BOOL rv = FALSE;
  234. S32 count = mObjectIDs.count();
  235. if(mCurrentObjectID.isNull() && (count > 0))
  236. {
  237. mCurrentObjectID = mObjectIDs.get(0);
  238. llinfos << "LLFloaterScriptQueue::popNext() - mCurrentID: "
  239. << mCurrentObjectID << llendl;
  240. mObjectIDs.remove(0);
  241. LLViewerObject* obj = gObjectList.findObject(mCurrentObjectID);
  242. if(obj)
  243. {
  244. llinfos << "LLFloaterScriptQueue::popNext() requesting inv for "
  245. << mCurrentObjectID << llendl;
  246. LLUUID* id = new LLUUID(getKey().asUUID());
  247. registerVOInventoryListener(obj,id);
  248. requestVOInventory();
  249. rv = TRUE;
  250. }
  251. }
  252. return rv;
  253. }
  256. ///----------------------------------------------------------------------------
  257. /// Class LLFloaterCompileQueue
  258. ///----------------------------------------------------------------------------
  260. class LLCompileFloaterUploadQueueSupplier : public LLAssetUploadQueueSupplier
  261. {
  262. public:
  264. LLCompileFloaterUploadQueueSupplier(const LLUUID& queue_id) :
  265. mQueueId(queue_id)
  266. {
  267. }
  269. virtual LLAssetUploadQueue* get() const 
  270. {
  271. LLFloaterCompileQueue* queue = LLFloaterReg::findTypedInstance<LLFloaterCompileQueue>("compile_queue", LLSD(mQueueId));
  272. if(NULL == queue)
  273. {
  274. return NULL;
  275. }
  276. return queue->getUploadQueue();
  277. }
  279. virtual void log(std::string message) const
  280. {
  281. LLFloaterCompileQueue* queue = LLFloaterReg::findTypedInstance<LLFloaterCompileQueue>("compile_queue", LLSD(mQueueId));
  282. if(NULL == queue)
  283. {
  284. return;
  285. }
  287. queue->getChild<LLScrollListCtrl>("queue output")->setCommentText(message);
  288. }
  290. private:
  291. LLUUID mQueueId;
  292. };
  294. LLFloaterCompileQueue::LLFloaterCompileQueue(const LLSD& key)
  295.   : LLFloaterScriptQueue(key)
  296. {
  297. setTitle(LLTrans::getString("CompileQueueTitle"));
  298. setStartString(LLTrans::getString("CompileQueueStart"));
  299.    
  300. mUploadQueue = new LLAssetUploadQueue(new LLCompileFloaterUploadQueueSupplier(key.asUUID()));
  301. }
  303. LLFloaterCompileQueue::~LLFloaterCompileQueue()
  304. { 
  305. }
  307. void LLFloaterCompileQueue::handleInventory(LLViewerObject *viewer_object,
  308. InventoryObjectList* inv)
  309. {
  310. // find all of the lsl, leaving off duplicates. We'll remove
  311. // all matching asset uuids on compilation success.
  313. typedef std::multimap<LLUUID, LLPointer<LLInventoryItem> > uuid_item_map;
  314. uuid_item_map asset_item_map;
  316. InventoryObjectList::const_iterator it = inv->begin();
  317. InventoryObjectList::const_iterator end = inv->end();
  318. for ( ; it != end; ++it)
  319. {
  320. if((*it)->getType() == LLAssetType::AT_LSL_TEXT)
  321. {
  322. LLInventoryItem* item = (LLInventoryItem*)((LLInventoryObject*)(*it));
  323. // Check permissions before allowing the user to retrieve data.
  324. if (item->getPermissions().allowModifyBy(gAgent.getID(), gAgent.getGroupID())  &&
  325. item->getPermissions().allowCopyBy(gAgent.getID(), gAgent.getGroupID()) )
  326. {
  327. LLPointer<LLViewerInventoryItem> script = new LLViewerInventoryItem(item);
  328. mCurrentScripts.put(script);
  329. asset_item_map.insert(std::make_pair(item->getAssetUUID(), item));
  330. }
  331. }
  332. }
  334. if (asset_item_map.empty())
  335. {
  336. // There are no scripts in this object.  move on.
  337. nextObject();
  338. }
  339. else
  340. {
  341. // request all of the assets.
  342. uuid_item_map::iterator iter;
  343. for(iter = asset_item_map.begin(); iter != asset_item_map.end(); iter++)
  344. {
  345. LLInventoryItem *itemp = iter->second;
  346. LLScriptQueueData* datap = new LLScriptQueueData(getKey().asUUID(),
  347.  itemp->getName(),
  348.  viewer_object->getID(),
  349.  itemp->getUUID());
  351. //llinfos << "ITEM NAME 2: " << names.get(i) << llendl;
  352. gAssetStorage->getInvItemAsset(viewer_object->getRegion()->getHost(),
  353. gAgent.getID(),
  354. gAgent.getSessionID(),
  355. itemp->getPermissions().getOwner(),
  356. viewer_object->getID(),
  357. itemp->getUUID(),
  358. itemp->getAssetUUID(),
  359. itemp->getType(),
  360. LLFloaterCompileQueue::scriptArrived,
  361. (void*)datap);
  362. }
  363. }
  364. }
  366. // This is the callback for when each script arrives
  367. // static
  368. void LLFloaterCompileQueue::scriptArrived(LLVFS *vfs, const LLUUID& asset_id,
  369.   LLAssetType::EType type,
  370.   void* user_data, S32 status, LLExtStat ext_status)
  371. {
  372. llinfos << "LLFloaterCompileQueue::scriptArrived()" << llendl;
  373. LLScriptQueueData* data = (LLScriptQueueData*)user_data;
  374. if(!data)
  375. {
  376. return;
  377. }
  378. LLFloaterCompileQueue* queue = LLFloaterReg::findTypedInstance<LLFloaterCompileQueue>("compile_queue", data->mQueueID);
  380. std::string buffer;
  381. if(queue && (0 == status))
  382. {
  383. //llinfos << "ITEM NAME 3: " << data->mScriptName << llendl;
  385. // Dump this into a file on the local disk so we can compile it.
  386. std::string filename;
  387. LLVFile file(vfs, asset_id, type);
  388. std::string uuid_str;
  389. asset_id.toString(uuid_str);
  390. filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str) + llformat(".%s",LLAssetType::lookup(type));
  392. const bool is_running = true;
  393. LLViewerObject* object = gObjectList.findObject(data->mTaskId);
  394. if (object)
  395. {
  396. std::string url = object->getRegion()->getCapability("UpdateScriptTask");
  397. if(!url.empty())
  398. {
  399. // Read script source in to buffer.
  400. U32 script_size = file.getSize();
  401. U8* script_data = new U8[script_size];
  402. file.read(script_data, script_size);
  404. queue->mUploadQueue->queue(filename, data->mTaskId, 
  405.    data->mItemId, is_running, queue->mMono, queue->getKey().asUUID(),
  406.    script_data, script_size, data->mScriptName);
  407. }
  408. else
  409. {
  410. // It's now in the file, now compile it.
  411. buffer = LLTrans::getString("CompileQueueDownloadedCompiling") + (": ") + data->mScriptName;
  413. // Write script to local file for compilation.
  414. LLFILE *fp = LLFile::fopen(filename, "wb");  /*Flawfinder: ignore*/
  415. if (fp)
  416. {
  417. const S32 buf_size = 65536;
  418. U8 copy_buf[buf_size];
  420. while (file.read(copy_buf, buf_size))   /*Flawfinder: ignore*/
  421. {
  422. if (fwrite(copy_buf, file.getLastBytesRead(), 1, fp) < 1)
  423. {
  424. // return a bad file error if we can't write the whole thing
  425. status = LL_ERR_CANNOT_OPEN_FILE;
  426. }
  427. }
  429. fclose(fp);
  430. }
  431. else
  432. {
  433. llerrs << "Unable to find object to compile" << llendl;
  434. }
  436. // TODO: babbage: No compile if no cap.
  437. queue->compile(filename, data->mItemId);
  439. // Delete it after we're done compiling?
  440. LLFile::remove(filename);
  441. }
  442. }
  443. }
  444. else
  445. {
  446. LLViewerStats::getInstance()->incStat( LLViewerStats::ST_DOWNLOAD_FAILED );
  448. if( LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE == status )
  449. {
  450. LLSD args;
  451. args["MESSAGE"] = LLTrans::getString("CompileQueueScriptNotFound");
  452. LLNotificationsUtil::add("SystemMessage", args);
  454. buffer = LLTrans::getString("CompileQueueProblemDownloading") + (": ") + data->mScriptName;
  455. }
  456. else if (LL_ERR_INSUFFICIENT_PERMISSIONS == status)
  457. {
  458. LLSD args;
  459. args["MESSAGE"] = LLTrans::getString("CompileQueueInsufficientPermDownload");
  460. LLNotificationsUtil::add("SystemMessage", args);
  462. buffer = LLTrans::getString("CompileQueueInsufficientPermFor") + (": ") + data->mScriptName;
  463. }
  464. else
  465. {
  466. buffer = LLTrans::getString("CompileQueueUnknownFailure") + (" ") + data->mScriptName;
  467. }
  469. llwarns << "Problem downloading script asset." << llendl;
  470. if(queue) queue->removeItemByItemID(data->mItemId);
  471. }
  472. if(queue && (buffer.size() > 0)) 
  473. {
  474. queue->getChild<LLScrollListCtrl>("queue output")->setCommentText(buffer);
  475. }
  476. delete data;
  477. }
  479. // static
  480. void LLFloaterCompileQueue::onSaveTextComplete(const LLUUID& asset_id, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
  481. {
  482. llinfos << "LLFloaterCompileQueue::onSaveTextComplete()" << llendl;
  483. if (status)
  484. {
  485. llwarns << "Unable to save text for script." << llendl;
  486. LLSD args;
  487. args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
  488. LLNotificationsUtil::add("CompileQueueSaveText", args);
  489. }
  490. }
  492. // static
  493. void LLFloaterCompileQueue::onSaveBytecodeComplete(const LLUUID& asset_id, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
  494. {
  495. llinfos << "LLFloaterCompileQueue::onSaveBytecodeComplete()" << llendl;
  496. LLCompileQueueData* data = (LLCompileQueueData*)user_data;
  497. LLFloaterCompileQueue* queue = LLFloaterReg::findTypedInstance<LLFloaterCompileQueue>("compile_queue", data->mQueueID);
  498. if(queue && (0 == status) && data)
  499. {
  500. queue->saveItemByItemID(data->mItemId);
  501. queue->removeItemByItemID(data->mItemId);
  502. }
  503. else
  504. {
  505. llwarns << "Unable to save bytecode for script." << llendl;
  506. LLSD args;
  507. args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
  508. LLNotificationsUtil::add("CompileQueueSaveBytecode", args);
  509. }
  510. delete data;
  511. data = NULL;
  512. }
  514. // compile the file given and save it out.
  515. void LLFloaterCompileQueue::compile(const std::string& filename,
  516. const LLUUID& item_id)
  517. {
  518. LLUUID new_asset_id;
  519. LLTransactionID tid;
  520. tid.generate();
  521. new_asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
  523. std::string uuid_string;
  524. new_asset_id.toString(uuid_string);
  525. std::string dst_filename;
  526. dst_filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_string) + ".lso";
  527. std::string err_filename;
  528. err_filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_string) + ".out";
  530. gAssetStorage->storeAssetData(filename, tid,
  531.   LLAssetType::AT_LSL_TEXT,
  532.   &onSaveTextComplete, NULL, FALSE);
  534. const BOOL compile_to_mono = FALSE;
  535. if(!lscript_compile(filename.c_str(), dst_filename.c_str(),
  536. err_filename.c_str(), compile_to_mono,
  537. uuid_string.c_str(), gAgent.isGodlike()))
  538. {
  539. llwarns << "compile failed" << llendl;
  540. removeItemByItemID(item_id);
  541. }
  542. else
  543. {
  544. llinfos << "compile successful." << llendl;
  546. // Save LSL bytecode
  547. LLCompileQueueData* data = new LLCompileQueueData(getKey().asUUID(), item_id);
  548. gAssetStorage->storeAssetData(dst_filename, new_asset_id,
  549. LLAssetType::AT_LSL_BYTECODE,
  550. &LLFloaterCompileQueue::onSaveBytecodeComplete,
  551. (void*)data, FALSE);
  552. }
  553. }
  555. void LLFloaterCompileQueue::removeItemByItemID(const LLUUID& asset_id)
  556. {
  557. llinfos << "LLFloaterCompileQueue::removeItemByAssetID()" << llendl;
  558. for(S32 i = 0; i < mCurrentScripts.count(); )
  559. {
  560. if(asset_id == mCurrentScripts.get(i)->getUUID())
  561. {
  562. mCurrentScripts.remove(i);
  563. }
  564. else
  565. {
  566. ++i;
  567. }
  568. }
  569. if(mCurrentScripts.count() == 0)
  570. {
  571. nextObject();
  572. }
  573. }
  575. const LLInventoryItem* LLFloaterCompileQueue::findItemByItemID(const LLUUID& asset_id) const
  576. {
  577. LLInventoryItem* result = NULL;
  578. S32 count = mCurrentScripts.count();
  579. for(S32 i = 0; i < count; ++i)
  580. {
  581. if(asset_id == mCurrentScripts.get(i)->getUUID())
  582. {
  583. result = mCurrentScripts.get(i);
  584. }
  585. }
  586. return result;
  587. }
  589. void LLFloaterCompileQueue::saveItemByItemID(const LLUUID& asset_id)
  590. {
  591. llinfos << "LLFloaterCompileQueue::saveItemByAssetID()" << llendl;
  592. LLViewerObject* viewer_object = gObjectList.findObject(mCurrentObjectID);
  593. if(viewer_object)
  594. {
  595. S32 count = mCurrentScripts.count();
  596. for(S32 i = 0; i < count; ++i)
  597. {
  598. if(asset_id == mCurrentScripts.get(i)->getUUID())
  599. {
  600. // *FIX: this auto-resets active to TRUE. That might
  601. // be a bad idea.
  602. viewer_object->saveScript(mCurrentScripts.get(i), TRUE, false);
  603. }
  604. }
  605. }
  606. else
  607. {
  608. llwarns << "Unable to finish save!" << llendl;
  609. }
  610. }
  612. ///----------------------------------------------------------------------------
  613. /// Class LLFloaterResetQueue
  614. ///----------------------------------------------------------------------------
  616. LLFloaterResetQueue::LLFloaterResetQueue(const LLSD& key)
  617.   : LLFloaterScriptQueue(key)
  618. {
  619. setTitle(LLTrans::getString("ResetQueueTitle"));
  620. setStartString(LLTrans::getString("ResetQueueStart"));
  621. }
  623. LLFloaterResetQueue::~LLFloaterResetQueue()
  624. { 
  625. }
  627. void LLFloaterResetQueue::handleInventory(LLViewerObject* viewer_obj,
  628.   InventoryObjectList* inv)
  629. {
  630. // find all of the lsl, leaving off duplicates. We'll remove
  631. // all matching asset uuids on compilation success.
  632. LLDynamicArray<const char*> names;
  634. InventoryObjectList::const_iterator it = inv->begin();
  635. InventoryObjectList::const_iterator end = inv->end();
  636. for ( ; it != end; ++it)
  637. {
  638. if((*it)->getType() == LLAssetType::AT_LSL_TEXT)
  639. {
  640. LLViewerObject* object = gObjectList.findObject(viewer_obj->getID());
  642. if (object)
  643. {
  644. LLInventoryItem* item = (LLInventoryItem*)((LLInventoryObject*)(*it));
  645. std::string buffer;
  646. buffer = getString("Resetting") + (": ") + item->getName();
  647. getChild<LLScrollListCtrl>("queue output")->setCommentText(buffer);
  648. LLMessageSystem* msg = gMessageSystem;
  649. msg->newMessageFast(_PREHASH_ScriptReset);
  650. msg->nextBlockFast(_PREHASH_AgentData);
  651. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  652. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  653. msg->nextBlockFast(_PREHASH_Script);
  654. msg->addUUIDFast(_PREHASH_ObjectID, viewer_obj->getID());
  655. msg->addUUIDFast(_PREHASH_ItemID, (*it)->getUUID());
  656. msg->sendReliable(object->getRegion()->getHost());
  657. }
  658. }
  659. }
  661. nextObject();
  662. }
  664. ///----------------------------------------------------------------------------
  665. /// Class LLFloaterRunQueue
  666. ///----------------------------------------------------------------------------
  668. LLFloaterRunQueue::LLFloaterRunQueue(const LLSD& key)
  669.   : LLFloaterScriptQueue(key)
  670. {
  671. setTitle(LLTrans::getString("RunQueueTitle"));
  672. setStartString(LLTrans::getString("RunQueueStart"));
  673. }
  675. LLFloaterRunQueue::~LLFloaterRunQueue()
  676. { 
  677. }
  679. void LLFloaterRunQueue::handleInventory(LLViewerObject* viewer_obj,
  680.   InventoryObjectList* inv)
  681. {
  682. // find all of the lsl, leaving off duplicates. We'll remove
  683. // all matching asset uuids on compilation success.
  684. LLDynamicArray<const char*> names;
  686. InventoryObjectList::const_iterator it = inv->begin();
  687. InventoryObjectList::const_iterator end = inv->end();
  688. for ( ; it != end; ++it)
  689. {
  690. if((*it)->getType() == LLAssetType::AT_LSL_TEXT)
  691. {
  692. LLViewerObject* object = gObjectList.findObject(viewer_obj->getID());
  694. if (object)
  695. {
  696. LLInventoryItem* item = (LLInventoryItem*)((LLInventoryObject*)(*it));
  697. LLScrollListCtrl* list = getChild<LLScrollListCtrl>("queue output");
  698. std::string buffer;
  699. buffer = getString("Running") + (": ") + item->getName();
  700. list->setCommentText(buffer);
  702. LLMessageSystem* msg = gMessageSystem;
  703. msg->newMessageFast(_PREHASH_SetScriptRunning);
  704. msg->nextBlockFast(_PREHASH_AgentData);
  705. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  706. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  707. msg->nextBlockFast(_PREHASH_Script);
  708. msg->addUUIDFast(_PREHASH_ObjectID, viewer_obj->getID());
  709. msg->addUUIDFast(_PREHASH_ItemID, (*it)->getUUID());
  710. msg->addBOOLFast(_PREHASH_Running, TRUE);
  711. msg->sendReliable(object->getRegion()->getHost());
  712. }
  713. }
  714. }
  716. nextObject();
  717. }
  719. ///----------------------------------------------------------------------------
  720. /// Class LLFloaterNotRunQueue
  721. ///----------------------------------------------------------------------------
  723. LLFloaterNotRunQueue::LLFloaterNotRunQueue(const LLSD& key)
  724.   : LLFloaterScriptQueue(key)
  725. {
  726. setTitle(LLTrans::getString("NotRunQueueTitle"));
  727. setStartString(LLTrans::getString("NotRunQueueStart"));
  728. }
  730. LLFloaterNotRunQueue::~LLFloaterNotRunQueue()
  731. { 
  732. }
  734. void LLFloaterNotRunQueue::handleInventory(LLViewerObject* viewer_obj,
  735.   InventoryObjectList* inv)
  736. {
  737. // find all of the lsl, leaving off duplicates. We'll remove
  738. // all matching asset uuids on compilation success.
  739. LLDynamicArray<const char*> names;
  741. InventoryObjectList::const_iterator it = inv->begin();
  742. InventoryObjectList::const_iterator end = inv->end();
  743. for ( ; it != end; ++it)
  744. {
  745. if((*it)->getType() == LLAssetType::AT_LSL_TEXT)
  746. {
  747. LLViewerObject* object = gObjectList.findObject(viewer_obj->getID());
  749. if (object)
  750. {
  751. LLInventoryItem* item = (LLInventoryItem*)((LLInventoryObject*)(*it));
  752. LLScrollListCtrl* list = getChild<LLScrollListCtrl>("queue output");
  753. std::string buffer;
  754. buffer = getString("NotRunning") + (": ") +item->getName();
  755. list->setCommentText(buffer);
  757. LLMessageSystem* msg = gMessageSystem;
  758. msg->newMessageFast(_PREHASH_SetScriptRunning);
  759. msg->nextBlockFast(_PREHASH_AgentData);
  760. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  761. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  762. msg->nextBlockFast(_PREHASH_Script);
  763. msg->addUUIDFast(_PREHASH_ObjectID, viewer_obj->getID());
  764. msg->addUUIDFast(_PREHASH_ItemID, (*it)->getUUID());
  765. msg->addBOOLFast(_PREHASH_Running, FALSE);
  766. msg->sendReliable(object->getRegion()->getHost());
  767. }
  768. }
  769. }
  771. nextObject();
  772. }
  774. ///----------------------------------------------------------------------------
  775. /// Local function definitions
  776. ///----------------------------------------------------------------------------