/indra/newview/llcompilequeue.cpp

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