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

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

游戏引擎

开发平台：

C++ Builder

llpreviewscript.cpp：源码内容
  1. /** 
  2.  * @file llpreviewscript.cpp
  3.  * @brief LLPreviewScript 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. #include "llviewerprecompiledheaders.h"
  35. #include "llpreviewscript.h"
  37. #include "llassetstorage.h"
  38. #include "llassetuploadresponders.h"
  39. #include "llbutton.h"
  40. #include "llcheckboxctrl.h"
  41. #include "llcombobox.h"
  42. #include "lldir.h"
  43. #include "llfloaterreg.h"
  44. #include "llinventorymodel.h"
  45. #include "llkeyboard.h"
  46. #include "lllineeditor.h"
  47. #include "llhelp.h"
  48. #include "llnotificationsutil.h"
  49. #include "llresmgr.h"
  50. #include "llscrollbar.h"
  51. #include "llscrollcontainer.h"
  52. #include "llscrolllistctrl.h"
  53. #include "llscrolllistitem.h"
  54. #include "llscrolllistcell.h"
  55. #include "llslider.h"
  56. #include "lscript_rt_interface.h"
  57. #include "lscript_library.h"
  58. #include "lscript_export.h"
  59. #include "lltextbox.h"
  60. #include "lltooldraganddrop.h"
  61. #include "llvfile.h"
  63. #include "llagent.h"
  64. #include "llmenugl.h"
  65. #include "roles_constants.h"
  66. #include "llselectmgr.h"
  67. #include "llviewerinventory.h"
  68. #include "llviewermenu.h"
  69. #include "llviewerobject.h"
  70. #include "llviewerobjectlist.h"
  71. #include "llviewerregion.h"
  72. #include "llkeyboard.h"
  73. #include "llscrollcontainer.h"
  74. #include "llcheckboxctrl.h"
  75. #include "llselectmgr.h"
  76. #include "lltooldraganddrop.h"
  77. #include "llscrolllistctrl.h"
  78. #include "lltextbox.h"
  79. #include "llslider.h"
  80. #include "lldir.h"
  81. #include "llcombobox.h"
  82. #include "llviewerstats.h"
  83. #include "llviewertexteditor.h"
  84. #include "llviewerwindow.h"
  85. #include "lluictrlfactory.h"
  86. #include "llmediactrl.h"
  87. #include "lluictrlfactory.h"
  88. #include "lltrans.h"
  89. #include "llviewercontrol.h"
  90. #include "llappviewer.h"
  92. const std::string HELLO_LSL =
  93. "defaultn"
  94. "{n"
  95. "    state_entry()n"
  96.     "    {n"
  97.     "        llSay(0, "Hello, Avatar!");n"
  98.     "    }n"
  99. "n"
  100. "    touch_start(integer total_number)n"
  101. "    {n"
  102. "        llSay(0, "Touched.");n"
  103. "    }n"
  104. "}n";
  105. const std::string HELP_LSL_PORTAL_TOPIC = "LSL_Portal";
  107. const std::string DEFAULT_SCRIPT_NAME = "New Script"; // *TODO:Translate?
  108. const std::string DEFAULT_SCRIPT_DESC = "(No Description)"; // *TODO:Translate?
  110. // Description and header information
  112. const S32 MAX_EXPORT_SIZE = 1000;
  114. const S32 MAX_HISTORY_COUNT = 10;
  115. const F32 LIVE_HELP_REFRESH_TIME = 1.f;
  117. static bool have_script_upload_cap(LLUUID& object_id)
  118. {
  119. LLViewerObject* object = gObjectList.findObject(object_id);
  120. return object && (! object->getRegion()->getCapability("UpdateScriptTask").empty());
  121. }
  123. /// ---------------------------------------------------------------------------
  124. /// LLFloaterScriptSearch
  125. /// ---------------------------------------------------------------------------
  126. class LLFloaterScriptSearch : public LLFloater
  127. {
  128. public:
  129. LLFloaterScriptSearch(LLScriptEdCore* editor_core);
  130. ~LLFloaterScriptSearch();
  132. /*virtual*/ BOOL postBuild();
  133. static void show(LLScriptEdCore* editor_core);
  134. static void onBtnSearch(void* userdata);
  135. void handleBtnSearch();
  137. static void onBtnReplace(void* userdata);
  138. void handleBtnReplace();
  140. static void onBtnReplaceAll(void* userdata);
  141. void handleBtnReplaceAll();
  143. LLScriptEdCore* getEditorCore() { return mEditorCore; }
  144. static LLFloaterScriptSearch* getInstance() { return sInstance; }
  146. private:
  148. LLScriptEdCore* mEditorCore;
  150. static LLFloaterScriptSearch* sInstance;
  151. };
  153. LLFloaterScriptSearch* LLFloaterScriptSearch::sInstance = NULL;
  155. LLFloaterScriptSearch::LLFloaterScriptSearch(LLScriptEdCore* editor_core)
  156. : LLFloater(LLSD()),
  157. mEditorCore(editor_core)
  158. {
  159. LLUICtrlFactory::getInstance()->buildFloater(this,"floater_script_search.xml", NULL);
  161. sInstance = this;
  163. // find floater in which script panel is embedded
  164. LLView* viewp = (LLView*)editor_core;
  165. while(viewp)
  166. {
  167. LLFloater* floaterp = dynamic_cast<LLFloater*>(viewp);
  168. if (floaterp)
  169. {
  170. floaterp->addDependentFloater(this);
  171. break;
  172. }
  173. viewp = viewp->getParent();
  174. }
  175. }
  177. BOOL LLFloaterScriptSearch::postBuild()
  178. {
  179. childSetAction("search_btn", onBtnSearch,this);
  180. childSetAction("replace_btn", onBtnReplace,this);
  181. childSetAction("replace_all_btn", onBtnReplaceAll,this);
  183. setDefaultBtn("search_btn");
  185. return TRUE;
  186. }
  188. //static 
  189. void LLFloaterScriptSearch::show(LLScriptEdCore* editor_core)
  190. {
  191. if (sInstance && sInstance->mEditorCore && sInstance->mEditorCore != editor_core)
  192. {
  193. sInstance->closeFloater();
  194. delete sInstance;
  195. }
  197. if (!sInstance)
  198. {
  199. // sInstance will be assigned in the constructor.
  200. new LLFloaterScriptSearch(editor_core);
  201. }
  203. sInstance->openFloater();
  204. }
  206. LLFloaterScriptSearch::~LLFloaterScriptSearch()
  207. {
  208. sInstance = NULL;
  209. }
  211. // static 
  212. void LLFloaterScriptSearch::onBtnSearch(void *userdata)
  213. {
  214. LLFloaterScriptSearch* self = (LLFloaterScriptSearch*)userdata;
  215. self->handleBtnSearch();
  216. }
  218. void LLFloaterScriptSearch::handleBtnSearch()
  219. {
  220. LLCheckBoxCtrl* caseChk = getChild<LLCheckBoxCtrl>("case_text");
  221. mEditorCore->mEditor->selectNext(childGetText("search_text"), caseChk->get());
  222. }
  224. // static 
  225. void LLFloaterScriptSearch::onBtnReplace(void *userdata)
  226. {
  227. LLFloaterScriptSearch* self = (LLFloaterScriptSearch*)userdata;
  228. self->handleBtnReplace();
  229. }
  231. void LLFloaterScriptSearch::handleBtnReplace()
  232. {
  233. LLCheckBoxCtrl* caseChk = getChild<LLCheckBoxCtrl>("case_text");
  234. mEditorCore->mEditor->replaceText(childGetText("search_text"), childGetText("replace_text"), caseChk->get());
  235. }
  237. // static 
  238. void LLFloaterScriptSearch::onBtnReplaceAll(void *userdata)
  239. {
  240. LLFloaterScriptSearch* self = (LLFloaterScriptSearch*)userdata;
  241. self->handleBtnReplaceAll();
  242. }
  244. void LLFloaterScriptSearch::handleBtnReplaceAll()
  245. {
  246. LLCheckBoxCtrl* caseChk = getChild<LLCheckBoxCtrl>("case_text");
  247. mEditorCore->mEditor->replaceTextAll(childGetText("search_text"), childGetText("replace_text"), caseChk->get());
  248. }
  252. /// ---------------------------------------------------------------------------
  253. /// LLScriptEdCore
  254. /// ---------------------------------------------------------------------------
  256. struct LLSECKeywordCompare
  257. {
  258. bool operator()(const std::string& lhs, const std::string& rhs)
  259. {
  260. return (LLStringUtil::compareDictInsensitive( lhs, rhs ) < 0 );
  261. }
  262. };
  264. LLScriptEdCore::LLScriptEdCore(
  265. const std::string& sample,
  266. const LLHandle<LLFloater>& floater_handle,
  267. void (*load_callback)(void*),
  268. void (*save_callback)(void*, BOOL),
  269. void (*search_replace_callback) (void* userdata),
  270. void* userdata,
  271. S32 bottom_pad)
  272. :
  273. LLPanel(),
  274. mSampleText(sample),
  275. mEditor( NULL ),
  276. mLoadCallback( load_callback ),
  277. mSaveCallback( save_callback ),
  278. mSearchReplaceCallback( search_replace_callback ),
  279. mUserdata( userdata ),
  280. mForceClose( FALSE ),
  281. mLastHelpToken(NULL),
  282. mLiveHelpHistorySize(0),
  283. mEnableSave(FALSE),
  284. mHasScriptData(FALSE)
  285. {
  286. setFollowsAll();
  287. setBorderVisible(FALSE);
  289. setXMLFilename("panel_script_ed.xml");
  290. }
  292. LLScriptEdCore::~LLScriptEdCore()
  293. {
  294. deleteBridges();
  296. // If the search window is up for this editor, close it.
  297. LLFloaterScriptSearch* script_search = LLFloaterScriptSearch::getInstance();
  298. if (script_search && script_search->getEditorCore() == this)
  299. {
  300. script_search->closeFloater();
  301. delete script_search;
  302. }
  303. }
  305. BOOL LLScriptEdCore::postBuild()
  306. {
  307. mErrorList = getChild<LLScrollListCtrl>("lsl errors");
  309. mFunctions = getChild<LLComboBox>( "Insert...");
  311. childSetCommitCallback("Insert...", &LLScriptEdCore::onBtnInsertFunction, this);
  313. mEditor = getChild<LLViewerTextEditor>("Script Editor");
  315. childSetCommitCallback("lsl errors", &LLScriptEdCore::onErrorList, this);
  316. childSetAction("Save_btn", boost::bind(&LLScriptEdCore::doSave,this,FALSE));
  318. initMenu();
  321. std::vector<std::string> funcs;
  322. std::vector<std::string> tooltips;
  323. for (std::vector<LLScriptLibraryFunction>::const_iterator i = gScriptLibrary.mFunctions.begin();
  324. i != gScriptLibrary.mFunctions.end(); ++i)
  325. {
  326. // Make sure this isn't a god only function, or the agent is a god.
  327. if (!i->mGodOnly || gAgent.isGodlike())
  328. {
  329. std::string name = i->mName;
  330. funcs.push_back(name);
  332. std::string desc_name = "LSLTipText_";
  333. desc_name += name;
  334. std::string desc = LLTrans::getString(desc_name);
  336. F32 sleep_time = i->mSleepTime;
  337. if( sleep_time )
  338. {
  339. desc += "n";
  341. LLStringUtil::format_map_t args;
  342. args["[SLEEP_TIME]"] = llformat("%.1f", sleep_time );
  343. desc += LLTrans::getString("LSLTipSleepTime", args);
  344. }
  346. // A n linefeed is not part of xml. Let's add one to keep all
  347. // the tips one-per-line in strings.xml
  348. LLStringUtil::replaceString( desc, "\n", "n" );
  350. tooltips.push_back(desc);
  351. }
  352. }
  354. LLColor3 color(0.5f, 0.0f, 0.15f);
  355. mEditor->loadKeywords(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"keywords.ini"), funcs, tooltips, color);
  357. std::vector<std::string> primary_keywords;
  358. std::vector<std::string> secondary_keywords;
  359. LLKeywordToken *token;
  360. LLKeywords::keyword_iterator_t token_it;
  361. for (token_it = mEditor->keywordsBegin(); token_it != mEditor->keywordsEnd(); ++token_it)
  362. {
  363. token = token_it->second;
  364. if (token->getColor() == color) // Wow, what a disgusting hack.
  365. {
  366. primary_keywords.push_back( wstring_to_utf8str(token->getToken()) );
  367. }
  368. else
  369. {
  370. secondary_keywords.push_back( wstring_to_utf8str(token->getToken()) );
  371. }
  372. }
  374. // Case-insensitive dictionary sort for primary keywords. We don't sort the secondary
  375. // keywords. They're intelligently grouped in keywords.ini.
  376. std::stable_sort( primary_keywords.begin(), primary_keywords.end(), LLSECKeywordCompare() );
  378. for (std::vector<std::string>::const_iterator iter= primary_keywords.begin();
  379. iter!= primary_keywords.end(); ++iter)
  380. {
  381. mFunctions->add(*iter);
  382. }
  384. for (std::vector<std::string>::const_iterator iter= secondary_keywords.begin();
  385. iter!= secondary_keywords.end(); ++iter)
  386. {
  387. mFunctions->add(*iter);
  388. }
  390. return TRUE;
  391. }
  393. void LLScriptEdCore::initMenu()
  394. {
  395. // *TODO: Skinning - make these callbacks data driven
  396. LLMenuItemCallGL* menuItem;
  398. menuItem = getChild<LLMenuItemCallGL>("Save");
  399. menuItem->setClickCallback(boost::bind(&LLScriptEdCore::doSave, this, FALSE));
  400. menuItem->setEnableCallback(boost::bind(&LLScriptEdCore::hasChanged, this));
  402. menuItem = getChild<LLMenuItemCallGL>("Revert All Changes");
  403. menuItem->setClickCallback(boost::bind(&LLScriptEdCore::onBtnUndoChanges, this));
  404. menuItem->setEnableCallback(boost::bind(&LLScriptEdCore::hasChanged, this));
  406. menuItem = getChild<LLMenuItemCallGL>("Undo");
  407. menuItem->setClickCallback(boost::bind(&LLTextEditor::undo, mEditor));
  408. menuItem->setEnableCallback(boost::bind(&LLTextEditor::canUndo, mEditor));
  410. menuItem = getChild<LLMenuItemCallGL>("Redo");
  411. menuItem->setClickCallback(boost::bind(&LLTextEditor::redo, mEditor));
  412. menuItem->setEnableCallback(boost::bind(&LLTextEditor::canRedo, mEditor));
  414. menuItem = getChild<LLMenuItemCallGL>("Cut");
  415. menuItem->setClickCallback(boost::bind(&LLTextEditor::cut, mEditor));
  416. menuItem->setEnableCallback(boost::bind(&LLTextEditor::canCut, mEditor));
  418. menuItem = getChild<LLMenuItemCallGL>("Copy");
  419. menuItem->setClickCallback(boost::bind(&LLTextEditor::copy, mEditor));
  420. menuItem->setEnableCallback(boost::bind(&LLTextEditor::canCopy, mEditor));
  422. menuItem = getChild<LLMenuItemCallGL>("Paste");
  423. menuItem->setClickCallback(boost::bind(&LLTextEditor::paste, mEditor));
  424. menuItem->setEnableCallback(boost::bind(&LLTextEditor::canPaste, mEditor));
  426. menuItem = getChild<LLMenuItemCallGL>("Select All");
  427. menuItem->setClickCallback(boost::bind(&LLTextEditor::selectAll, mEditor));
  428. menuItem->setEnableCallback(boost::bind(&LLTextEditor::canSelectAll, mEditor));
  430. menuItem = getChild<LLMenuItemCallGL>("Search / Replace...");
  431. menuItem->setClickCallback(boost::bind(&LLFloaterScriptSearch::show, this));
  433. menuItem = getChild<LLMenuItemCallGL>("Help...");
  434. menuItem->setClickCallback(boost::bind(&LLScriptEdCore::onBtnHelp, this));
  436. menuItem = getChild<LLMenuItemCallGL>("Keyword Help...");
  437. menuItem->setClickCallback(boost::bind(&LLScriptEdCore::onBtnDynamicHelp, this));
  438. }
  440. void LLScriptEdCore::setScriptText(const std::string& text, BOOL is_valid)
  441. {
  442. if (mEditor)
  443. {
  444. mEditor->setText(text);
  445. mHasScriptData = is_valid;
  446. }
  447. }
  449. bool LLScriptEdCore::hasChanged()
  450. {
  451. if (!mEditor) return false;
  453. return ((!mEditor->isPristine() || mEnableSave) && mHasScriptData);
  454. }
  456. void LLScriptEdCore::draw()
  457. {
  458. BOOL script_changed = hasChanged();
  459. childSetEnabled("Save_btn", script_changed);
  461. if( mEditor->hasFocus() )
  462. {
  463. S32 line = 0;
  464. S32 column = 0;
  465. mEditor->getCurrentLineAndColumn( &line, &column, FALSE );  // don't include wordwrap
  466. LLStringUtil::format_map_t args;
  467. std::string cursor_pos;
  468. args["[LINE]"] = llformat ("%d", line);
  469. args["[COLUMN]"] = llformat ("%d", column);
  470. cursor_pos = LLTrans::getString("CursorPos", args);
  471. childSetText("line_col", cursor_pos);
  472. }
  473. else
  474. {
  475. childSetText("line_col", LLStringUtil::null);
  476. }
  478. updateDynamicHelp();
  480. LLPanel::draw();
  481. }
  483. void LLScriptEdCore::updateDynamicHelp(BOOL immediate)
  484. {
  485. LLFloater* help_floater = mLiveHelpHandle.get();
  486. if (!help_floater) return;
  488. // update back and forward buttons
  489. LLButton* fwd_button = help_floater->getChild<LLButton>("fwd_btn");
  490. LLButton* back_button = help_floater->getChild<LLButton>("back_btn");
  491. LLMediaCtrl* browser = help_floater->getChild<LLMediaCtrl>("lsl_guide_html");
  492. back_button->setEnabled(browser->canNavigateBack());
  493. fwd_button->setEnabled(browser->canNavigateForward());
  495. if (!immediate && !gSavedSettings.getBOOL("ScriptHelpFollowsCursor"))
  496. {
  497. return;
  498. }
  500. LLTextSegmentPtr segment = NULL;
  501. std::vector<LLTextSegmentPtr> selected_segments;
  502. mEditor->getSelectedSegments(selected_segments);
  504. // try segments in selection range first
  505. std::vector<LLTextSegmentPtr>::iterator segment_iter;
  506. for (segment_iter = selected_segments.begin(); segment_iter != selected_segments.end(); ++segment_iter)
  507. {
  508. if((*segment_iter)->getToken() && (*segment_iter)->getToken()->getType() == LLKeywordToken::WORD)
  509. {
  510. segment = *segment_iter;
  511. break;
  512. }
  513. }
  515. // then try previous segment in case we just typed it
  516. if (!segment)
  517. {
  518. const LLTextSegmentPtr test_segment = mEditor->getPreviousSegment();
  519. if(test_segment->getToken() && test_segment->getToken()->getType() == LLKeywordToken::WORD)
  520. {
  521. segment = test_segment;
  522. }
  523. }
  525. if (segment)
  526. {
  527. if (segment->getToken() != mLastHelpToken)
  528. {
  529. mLastHelpToken = segment->getToken();
  530. mLiveHelpTimer.start();
  531. }
  532. if (immediate || (mLiveHelpTimer.getStarted() && mLiveHelpTimer.getElapsedTimeF32() > LIVE_HELP_REFRESH_TIME))
  533. {
  534. std::string help_string = mEditor->getText().substr(segment->getStart(), segment->getEnd() - segment->getStart());
  535. setHelpPage(help_string);
  536. mLiveHelpTimer.stop();
  537. }
  538. }
  539. else
  540. {
  541. if (immediate)
  542. {
  543. setHelpPage(LLStringUtil::null);
  544. }
  545. }
  546. }
  548. void LLScriptEdCore::setHelpPage(const std::string& help_string)
  549. {
  550. LLFloater* help_floater = mLiveHelpHandle.get();
  551. if (!help_floater) return;
  553. LLMediaCtrl* web_browser = help_floater->getChild<LLMediaCtrl>("lsl_guide_html");
  554. if (!web_browser) return;
  556. LLComboBox* history_combo = help_floater->getChild<LLComboBox>("history_combo");
  557. if (!history_combo) return;
  559. LLUIString url_string = gSavedSettings.getString("LSLHelpURL");
  561. url_string.setArg("[LSL_STRING]", help_string);
  563. addHelpItemToHistory(help_string);
  565. web_browser->navigateTo(url_string);
  567. }
  570. void LLScriptEdCore::addHelpItemToHistory(const std::string& help_string)
  571. {
  572. if (help_string.empty()) return;
  574. LLFloater* help_floater = mLiveHelpHandle.get();
  575. if (!help_floater) return;
  577. LLComboBox* history_combo = help_floater->getChild<LLComboBox>("history_combo");
  578. if (!history_combo) return;
  580. // separate history items from full item list
  581. if (mLiveHelpHistorySize == 0)
  582. {
  583. history_combo->addSeparator(ADD_TOP);
  584. }
  585. // delete all history items over history limit
  586. while(mLiveHelpHistorySize > MAX_HISTORY_COUNT - 1)
  587. {
  588. history_combo->remove(mLiveHelpHistorySize - 1);
  589. mLiveHelpHistorySize--;
  590. }
  592. history_combo->setSimple(help_string);
  593. S32 index = history_combo->getCurrentIndex();
  595. // if help string exists in the combo box
  596. if (index >= 0)
  597. {
  598. S32 cur_index = history_combo->getCurrentIndex();
  599. if (cur_index < mLiveHelpHistorySize)
  600. {
  601. // item found in history, bubble up to top
  602. history_combo->remove(history_combo->getCurrentIndex());
  603. mLiveHelpHistorySize--;
  604. }
  605. }
  606. history_combo->add(help_string, LLSD(help_string), ADD_TOP);
  607. history_combo->selectFirstItem();
  608. mLiveHelpHistorySize++;
  609. }
  611. BOOL LLScriptEdCore::canClose()
  612. {
  613. if(mForceClose || !hasChanged())
  614. {
  615. return TRUE;
  616. }
  617. else
  618. {
  619. // Bring up view-modal dialog: Save changes? Yes, No, Cancel
  620. LLNotificationsUtil::add("SaveChanges", LLSD(), LLSD(), boost::bind(&LLScriptEdCore::handleSaveChangesDialog, this, _1, _2));
  621. return FALSE;
  622. }
  623. }
  625. bool LLScriptEdCore::handleSaveChangesDialog(const LLSD& notification, const LLSD& response )
  626. {
  627. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  628. switch( option )
  629. {
  630. case 0:  // "Yes"
  631. // close after saving
  632. doSave( TRUE );
  633. break;
  635. case 1:  // "No"
  636. mForceClose = TRUE;
  637. // This will close immediately because mForceClose is true, so we won't
  638. // infinite loop with these dialogs. JC
  639. ((LLFloater*) getParent())->closeFloater();
  640. break;
  642. case 2: // "Cancel"
  643. default:
  644. // If we were quitting, we didn't really mean it.
  645.         LLAppViewer::instance()->abortQuit();
  646. break;
  647. }
  648. return false;
  649. }
  651. void LLScriptEdCore::onBtnHelp()
  652. {
  653. LLUI::sHelpImpl->showTopic(HELP_LSL_PORTAL_TOPIC);
  654. }
  656. void LLScriptEdCore::onBtnDynamicHelp()
  657. {
  658. LLFloater* live_help_floater = mLiveHelpHandle.get();
  659. if (!live_help_floater)
  660. {
  661. live_help_floater = new LLFloater(LLSD());
  662. LLUICtrlFactory::getInstance()->buildFloater(live_help_floater, "floater_lsl_guide.xml", NULL);
  663. LLFloater* parent = dynamic_cast<LLFloater*>(getParent());
  664. llassert(parent);
  665. if (parent)
  666. parent->addDependentFloater(live_help_floater, TRUE);
  667. live_help_floater->childSetCommitCallback("lock_check", onCheckLock, this);
  668. live_help_floater->childSetValue("lock_check", gSavedSettings.getBOOL("ScriptHelpFollowsCursor"));
  669. live_help_floater->childSetCommitCallback("history_combo", onHelpComboCommit, this);
  670. live_help_floater->childSetAction("back_btn", onClickBack, this);
  671. live_help_floater->childSetAction("fwd_btn", onClickForward, this);
  673. LLMediaCtrl* browser = live_help_floater->getChild<LLMediaCtrl>("lsl_guide_html");
  674. browser->setAlwaysRefresh(TRUE);
  676. LLComboBox* help_combo = live_help_floater->getChild<LLComboBox>("history_combo");
  677. LLKeywordToken *token;
  678. LLKeywords::keyword_iterator_t token_it;
  679. for (token_it = mEditor->keywordsBegin(); 
  680.      token_it != mEditor->keywordsEnd(); 
  681.      ++token_it)
  682. {
  683. token = token_it->second;
  684. help_combo->add(wstring_to_utf8str(token->getToken()));
  685. }
  686. help_combo->sortByName();
  688. // re-initialize help variables
  689. mLastHelpToken = NULL;
  690. mLiveHelpHandle = live_help_floater->getHandle();
  691. mLiveHelpHistorySize = 0;
  692. }
  694. BOOL visible = TRUE;
  695. BOOL take_focus = TRUE;
  696. live_help_floater->setVisible(visible);
  697. live_help_floater->setFrontmost(take_focus);
  699. updateDynamicHelp(TRUE);
  700. }
  702. //static 
  703. void LLScriptEdCore::onClickBack(void* userdata)
  704. {
  705. LLScriptEdCore* corep = (LLScriptEdCore*)userdata;
  706. LLFloater* live_help_floater = corep->mLiveHelpHandle.get();
  707. if (live_help_floater)
  708. {
  709. LLMediaCtrl* browserp = live_help_floater->getChild<LLMediaCtrl>("lsl_guide_html");
  710. if (browserp)
  711. {
  712. browserp->navigateBack();
  713. }
  714. }
  715. }
  717. //static 
  718. void LLScriptEdCore::onClickForward(void* userdata)
  719. {
  720. LLScriptEdCore* corep = (LLScriptEdCore*)userdata;
  721. LLFloater* live_help_floater = corep->mLiveHelpHandle.get();
  722. if (live_help_floater)
  723. {
  724. LLMediaCtrl* browserp = live_help_floater->getChild<LLMediaCtrl>("lsl_guide_html");
  725. if (browserp)
  726. {
  727. browserp->navigateForward();
  728. }
  729. }
  730. }
  732. // static
  733. void LLScriptEdCore::onCheckLock(LLUICtrl* ctrl, void* userdata)
  734. {
  735. LLScriptEdCore* corep = (LLScriptEdCore*)userdata;
  737. // clear out token any time we lock the frame, so we will refresh web page immediately when unlocked
  738. gSavedSettings.setBOOL("ScriptHelpFollowsCursor", ctrl->getValue().asBoolean());
  740. corep->mLastHelpToken = NULL;
  741. }
  743. // static 
  744. void LLScriptEdCore::onBtnInsertSample(void* userdata)
  745. {
  746. LLScriptEdCore* self = (LLScriptEdCore*) userdata;
  748. // Insert sample code
  749. self->mEditor->selectAll();
  750. self->mEditor->cut();
  751. self->mEditor->insertText(self->mSampleText);
  752. }
  754. // static 
  755. void LLScriptEdCore::onHelpComboCommit(LLUICtrl* ctrl, void* userdata)
  756. {
  757. LLScriptEdCore* corep = (LLScriptEdCore*)userdata;
  759. LLFloater* live_help_floater = corep->mLiveHelpHandle.get();
  760. if (live_help_floater)
  761. {
  762. std::string help_string = ctrl->getValue().asString();
  764. corep->addHelpItemToHistory(help_string);
  766. LLMediaCtrl* web_browser = live_help_floater->getChild<LLMediaCtrl>("lsl_guide_html");
  767. LLUIString url_string = gSavedSettings.getString("LSLHelpURL");
  768. url_string.setArg("[LSL_STRING]", help_string);
  769. web_browser->navigateTo(url_string);
  770. }
  771. }
  773. // static 
  774. void LLScriptEdCore::onBtnInsertFunction(LLUICtrl *ui, void* userdata)
  775. {
  776. LLScriptEdCore* self = (LLScriptEdCore*) userdata;
  778. // Insert sample code
  779. if(self->mEditor->getEnabled())
  780. {
  781. self->mEditor->insertText(self->mFunctions->getSimple());
  782. }
  783. self->mEditor->setFocus(TRUE);
  784. self->setHelpPage(self->mFunctions->getSimple());
  785. }
  787. void LLScriptEdCore::doSave( BOOL close_after_save )
  788. {
  789. LLViewerStats::getInstance()->incStat( LLViewerStats::ST_LSL_SAVE_COUNT );
  791. if( mSaveCallback )
  792. {
  793. mSaveCallback( mUserdata, close_after_save );
  794. }
  795. }
  798. void LLScriptEdCore::onBtnUndoChanges()
  799. {
  800. if( !mEditor->tryToRevertToPristineState() )
  801. {
  802. LLNotificationsUtil::add("ScriptCannotUndo", LLSD(), LLSD(), boost::bind(&LLScriptEdCore::handleReloadFromServerDialog, this, _1, _2));
  803. }
  804. }
  806. // static
  807. void LLScriptEdCore::onErrorList(LLUICtrl*, void* user_data)
  808. {
  809. LLScriptEdCore* self = (LLScriptEdCore*)user_data;
  810. LLScrollListItem* item = self->mErrorList->getFirstSelected();
  811. if(item)
  812. {
  813. // *FIX: replace with boost grep
  814. S32 row = 0;
  815. S32 column = 0;
  816. const LLScrollListCell* cell = item->getColumn(0);
  817. std::string line(cell->getValue().asString());
  818. line.erase(0, 1);
  819. LLStringUtil::replaceChar(line, ',',' ');
  820. LLStringUtil::replaceChar(line, ')',' ');
  821. sscanf(line.c_str(), "%d %d", &row, &column);
  822. //llinfos << "LLScriptEdCore::onErrorList() - " << row << ", "
  823. //<< column << llendl;
  824. self->mEditor->setCursor(row, column);
  825. self->mEditor->setFocus(TRUE);
  826. }
  827. }
  829. bool LLScriptEdCore::handleReloadFromServerDialog(const LLSD& notification, const LLSD& response )
  830. {
  831. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  832. switch( option )
  833. {
  834. case 0: // "Yes"
  835. if( mLoadCallback )
  836. {
  837. setScriptText(getString("loading"), FALSE);
  838. mLoadCallback(mUserdata);
  839. }
  840. break;
  842. case 1: // "No"
  843. break;
  845. default:
  846. llassert(0);
  847. break;
  848. }
  849. return false;
  850. }
  852. void LLScriptEdCore::selectFirstError()
  853. {
  854. // Select the first item;
  855. mErrorList->selectFirstItem();
  856. onErrorList(mErrorList, this);
  857. }
  860. struct LLEntryAndEdCore
  861. {
  862. LLScriptEdCore* mCore;
  863. LLEntryAndEdCore(LLScriptEdCore* core) :
  864. mCore(core)
  865. {}
  866. };
  868. void LLScriptEdCore::deleteBridges()
  869. {
  870. S32 count = mBridges.count();
  871. LLEntryAndEdCore* eandc;
  872. for(S32 i = 0; i < count; i++)
  873. {
  874. eandc = mBridges.get(i);
  875. delete eandc;
  876. mBridges[i] = NULL;
  877. }
  878. mBridges.reset();
  879. }
  881. // virtual
  882. BOOL LLScriptEdCore::handleKeyHere(KEY key, MASK mask)
  883. {
  884. bool just_control = MASK_CONTROL == (mask & MASK_MODIFIERS);
  886. if(('S' == key) && just_control)
  887. {
  888. if(mSaveCallback)
  889. {
  890. // don't close after saving
  891. mSaveCallback(mUserdata, FALSE);
  892. }
  894. return TRUE;
  895. }
  897. if(('F' == key) && just_control)
  898. {
  899. if(mSearchReplaceCallback)
  900. {
  901. mSearchReplaceCallback(mUserdata);
  902. }
  904. return TRUE;
  905. }
  907. return FALSE;
  908. }
  910. /// ---------------------------------------------------------------------------
  911. /// LLPreviewLSL
  912. /// ---------------------------------------------------------------------------
  914. struct LLScriptSaveInfo
  915. {
  916. LLUUID mItemUUID;
  917. std::string mDescription;
  918. LLTransactionID mTransactionID;
  920. LLScriptSaveInfo(const LLUUID& uuid, const std::string& desc, LLTransactionID tid) :
  921. mItemUUID(uuid), mDescription(desc),  mTransactionID(tid) {}
  922. };
  926. //static
  927. void* LLPreviewLSL::createScriptEdPanel(void* userdata)
  928. {
  930. LLPreviewLSL *self = (LLPreviewLSL*)userdata;
  932. self->mScriptEd =  new LLScriptEdCore(
  933.    HELLO_LSL,
  934.    self->getHandle(),
  935.    LLPreviewLSL::onLoad,
  936.    LLPreviewLSL::onSave,
  937.    LLPreviewLSL::onSearchReplace,
  938.    self,
  939.    0);
  941. return self->mScriptEd;
  942. }
  945. LLPreviewLSL::LLPreviewLSL(const LLSD& key )
  946.   : LLPreview( key ),
  947. mPendingUploads(0)
  948. {
  949. mFactoryMap["script panel"] = LLCallbackMap(LLPreviewLSL::createScriptEdPanel, this);
  950. //Called from floater reg: LLUICtrlFactory::getInstance()->buildFloater(this,"floater_script_preview.xml", FALSE);
  951. }
  953. // virtual
  954. BOOL LLPreviewLSL::postBuild()
  955. {
  956. const LLInventoryItem* item = getItem();
  958. llassert(item);
  959. if (item)
  960. {
  961. childSetText("desc", item->getDescription());
  962. }
  963. childSetCommitCallback("desc", LLPreview::onText, this);
  964. childSetPrevalidate("desc", &LLTextValidate::validateASCIIPrintableNoPipe);
  966. return LLPreview::postBuild();
  967. }
  969. // virtual
  970. void LLPreviewLSL::callbackLSLCompileSucceeded()
  971. {
  972. llinfos << "LSL Bytecode saved" << llendl;
  973. mScriptEd->mErrorList->setCommentText(LLTrans::getString("CompileSuccessful"));
  974. mScriptEd->mErrorList->setCommentText(LLTrans::getString("SaveComplete"));
  975. closeIfNeeded();
  976. }
  978. // virtual
  979. void LLPreviewLSL::callbackLSLCompileFailed(const LLSD& compile_errors)
  980. {
  981. llinfos << "Compile failed!" << llendl;
  983. for(LLSD::array_const_iterator line = compile_errors.beginArray();
  984. line < compile_errors.endArray();
  985. line++)
  986. {
  987. LLSD row;
  988. std::string error_message = line->asString();
  989. LLStringUtil::stripNonprintable(error_message);
  990. row["columns"][0]["value"] = error_message;
  991. row["columns"][0]["font"] = "OCRA";
  992. mScriptEd->mErrorList->addElement(row);
  993. }
  994. mScriptEd->selectFirstError();
  995. closeIfNeeded();
  996. }
  998. void LLPreviewLSL::loadAsset()
  999. {
  1000. // *HACK: we poke into inventory to see if it's there, and if so,
  1001. // then it might be part of the inventory library. If it's in the
  1002. // library, then you can see the script, but not modify it.
  1003. const LLInventoryItem* item = gInventory.getItem(mItemUUID);
  1004. BOOL is_library = item
  1005. && !gInventory.isObjectDescendentOf(mItemUUID,
  1006. gInventory.getRootFolderID());
  1007. if(!item)
  1008. {
  1009. // do the more generic search.
  1010. getItem();
  1011. }
  1012. if(item)
  1013. {
  1014. BOOL is_copyable = gAgent.allowOperation(PERM_COPY, 
  1015. item->getPermissions(), GP_OBJECT_MANIPULATE);
  1016. BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY,
  1017. item->getPermissions(), GP_OBJECT_MANIPULATE);
  1018. if (gAgent.isGodlike() || (is_copyable && (is_modifiable || is_library)))
  1019. {
  1020. LLUUID* new_uuid = new LLUUID(mItemUUID);
  1021. gAssetStorage->getInvItemAsset(LLHost::invalid,
  1022. gAgent.getID(),
  1023. gAgent.getSessionID(),
  1024. item->getPermissions().getOwner(),
  1025. LLUUID::null,
  1026. item->getUUID(),
  1027. item->getAssetUUID(),
  1028. item->getType(),
  1029. &LLPreviewLSL::onLoadComplete,
  1030. (void*)new_uuid,
  1031. TRUE);
  1032. mAssetStatus = PREVIEW_ASSET_LOADING;
  1033. }
  1034. else
  1035. {
  1036. mScriptEd->setScriptText(mScriptEd->getString("can_not_view"), FALSE);
  1037. mScriptEd->mEditor->makePristine();
  1038. mScriptEd->mEditor->setEnabled(FALSE);
  1039. mScriptEd->mFunctions->setEnabled(FALSE);
  1040. mAssetStatus = PREVIEW_ASSET_LOADED;
  1041. }
  1042. childSetVisible("lock", !is_modifiable);
  1043. mScriptEd->childSetEnabled("Insert...", is_modifiable);
  1044. }
  1045. else
  1046. {
  1047. mScriptEd->setScriptText(std::string(HELLO_LSL), TRUE);
  1048. mAssetStatus = PREVIEW_ASSET_LOADED;
  1049. }
  1050. }
  1053. BOOL LLPreviewLSL::canClose()
  1054. {
  1055. return mScriptEd->canClose();
  1056. }
  1058. void LLPreviewLSL::closeIfNeeded()
  1059. {
  1060. // Find our window and close it if requested.
  1061. getWindow()->decBusyCount();
  1062. mPendingUploads--;
  1063. if (mPendingUploads <= 0 && mCloseAfterSave)
  1064. {
  1065. closeFloater();
  1066. }
  1067. }
  1069. void LLPreviewLSL::onSearchReplace(void* userdata)
  1070. {
  1071. LLPreviewLSL* self = (LLPreviewLSL*)userdata;
  1072. LLScriptEdCore* sec = self->mScriptEd; 
  1073. LLFloaterScriptSearch::show(sec);
  1074. }
  1076. // static
  1077. void LLPreviewLSL::onLoad(void* userdata)
  1078. {
  1079. LLPreviewLSL* self = (LLPreviewLSL*)userdata;
  1080. self->loadAsset();
  1081. }
  1083. // static
  1084. void LLPreviewLSL::onSave(void* userdata, BOOL close_after_save)
  1085. {
  1086. LLPreviewLSL* self = (LLPreviewLSL*)userdata;
  1087. self->mCloseAfterSave = close_after_save;
  1088. self->saveIfNeeded();
  1089. }
  1091. // Save needs to compile the text in the buffer. If the compile
  1092. // succeeds, then save both assets out to the database. If the compile
  1093. // fails, go ahead and save the text anyway so that the user doesn't
  1094. // get too fucked.
  1095. void LLPreviewLSL::saveIfNeeded()
  1096. {
  1097. // llinfos << "LLPreviewLSL::saveIfNeeded()" << llendl;
  1098. if(!mScriptEd->hasChanged())
  1099. {
  1100. return;
  1101. }
  1103. mPendingUploads = 0;
  1104. mScriptEd->mErrorList->deleteAllItems();
  1105. mScriptEd->mEditor->makePristine();
  1107. // save off asset into file
  1108. LLTransactionID tid;
  1109. tid.generate();
  1110. LLAssetID asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
  1111. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,asset_id.asString());
  1112. std::string filename = filepath + ".lsl";
  1114. LLFILE* fp = LLFile::fopen(filename, "wb");
  1115. if(!fp)
  1116. {
  1117. llwarns << "Unable to write to " << filename << llendl;
  1119. LLSD row;
  1120. row["columns"][0]["value"] = "Error writing to local file. Is your hard drive full?";
  1121. row["columns"][0]["font"] = "SANSSERIF_SMALL";
  1122. mScriptEd->mErrorList->addElement(row);
  1123. return;
  1124. }
  1126. std::string utf8text = mScriptEd->mEditor->getText();
  1127. fputs(utf8text.c_str(), fp);
  1128. fclose(fp);
  1129. fp = NULL;
  1131. const LLInventoryItem *inv_item = getItem();
  1132. // save it out to asset server
  1133. std::string url = gAgent.getRegion()->getCapability("UpdateScriptAgent");
  1134. if(inv_item)
  1135. {
  1136. getWindow()->incBusyCount();
  1137. mPendingUploads++;
  1138. if (!url.empty())
  1139. {
  1140. uploadAssetViaCaps(url, filename, mItemUUID);
  1141. }
  1142. else if (gAssetStorage)
  1143. {
  1144. uploadAssetLegacy(filename, mItemUUID, tid);
  1145. }
  1146. }
  1147. }
  1149. void LLPreviewLSL::uploadAssetViaCaps(const std::string& url,
  1150.   const std::string& filename,
  1151.   const LLUUID& item_id)
  1152. {
  1153. llinfos << "Update Agent Inventory via capability" << llendl;
  1154. LLSD body;
  1155. body["item_id"] = item_id;
  1156. body["target"] = "lsl2";
  1157. LLHTTPClient::post(url, body, new LLUpdateAgentInventoryResponder(body, filename, LLAssetType::AT_LSL_TEXT));
  1158. }
  1160. void LLPreviewLSL::uploadAssetLegacy(const std::string& filename,
  1161.   const LLUUID& item_id,
  1162.   const LLTransactionID& tid)
  1163. {
  1164. LLLineEditor* descEditor = getChild<LLLineEditor>("desc");
  1165. LLScriptSaveInfo* info = new LLScriptSaveInfo(item_id,
  1166. descEditor->getText(),
  1167. tid);
  1168. gAssetStorage->storeAssetData(filename, tid,
  1169.   LLAssetType::AT_LSL_TEXT,
  1170.   &LLPreviewLSL::onSaveComplete,
  1171.   info);
  1173. LLAssetID asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
  1174. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,asset_id.asString());
  1175. std::string dst_filename = llformat("%s.lso", filepath.c_str());
  1176. std::string err_filename = llformat("%s.out", filepath.c_str());
  1178. const BOOL compile_to_mono = FALSE;
  1179. if(!lscript_compile(filename.c_str(),
  1180. dst_filename.c_str(),
  1181. err_filename.c_str(),
  1182. compile_to_mono,
  1183. asset_id.asString().c_str(),
  1184. gAgent.isGodlike()))
  1185. {
  1186. llinfos << "Compile failed!" << llendl;
  1187. //char command[256];
  1188. //sprintf(command, "type %sn", err_filename.c_str());
  1189. //system(command);
  1191. // load the error file into the error scrolllist
  1192. LLFILE* fp = LLFile::fopen(err_filename, "r");
  1193. if(fp)
  1194. {
  1195. char buffer[MAX_STRING]; /*Flawfinder: ignore*/
  1196. std::string line;
  1197. while(!feof(fp)) 
  1198. {
  1199. if (fgets(buffer, MAX_STRING, fp) == NULL)
  1200. {
  1201. buffer[0] = '';
  1202. }
  1203. if(feof(fp))
  1204. {
  1205. break;
  1206. }
  1207. else
  1208. {
  1209. line.assign(buffer);
  1210. LLStringUtil::stripNonprintable(line);
  1212. LLSD row;
  1213. row["columns"][0]["value"] = line;
  1214. row["columns"][0]["font"] = "OCRA";
  1215. mScriptEd->mErrorList->addElement(row);
  1216. }
  1217. }
  1218. fclose(fp);
  1219. mScriptEd->selectFirstError();
  1220. }
  1221. }
  1222. else
  1223. {
  1224. llinfos << "Compile worked!" << llendl;
  1225. if(gAssetStorage)
  1226. {
  1227. getWindow()->incBusyCount();
  1228. mPendingUploads++;
  1229. LLUUID* this_uuid = new LLUUID(mItemUUID);
  1230. gAssetStorage->storeAssetData(dst_filename,
  1231.   tid,
  1232.   LLAssetType::AT_LSL_BYTECODE,
  1233.   &LLPreviewLSL::onSaveBytecodeComplete,
  1234.   (void**)this_uuid);
  1235. }
  1236. }
  1238. // get rid of any temp files left lying around
  1239. LLFile::remove(filename);
  1240. LLFile::remove(err_filename);
  1241. LLFile::remove(dst_filename);
  1242. }
  1245. // static
  1246. void LLPreviewLSL::onSaveComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
  1247. {
  1248. LLScriptSaveInfo* info = reinterpret_cast<LLScriptSaveInfo*>(user_data);
  1249. if(0 == status)
  1250. {
  1251. if (info)
  1252. {
  1253. const LLViewerInventoryItem* item;
  1254. item = (const LLViewerInventoryItem*)gInventory.getItem(info->mItemUUID);
  1255. if(item)
  1256. {
  1257. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  1258. new_item->setAssetUUID(asset_uuid);
  1259. new_item->setTransactionID(info->mTransactionID);
  1260. new_item->updateServer(FALSE);
  1261. gInventory.updateItem(new_item);
  1262. gInventory.notifyObservers();
  1263. }
  1264. else
  1265. {
  1266. llwarns << "Inventory item for script " << info->mItemUUID
  1267. << " is no longer in agent inventory." << llendl;
  1268. }
  1270. // Find our window and close it if requested.
  1271. LLPreviewLSL* self = LLFloaterReg::findTypedInstance<LLPreviewLSL>("preview_script", info->mItemUUID);
  1272. if (self)
  1273. {
  1274. getWindow()->decBusyCount();
  1275. self->mPendingUploads--;
  1276. if (self->mPendingUploads <= 0
  1277. && self->mCloseAfterSave)
  1278. {
  1279. self->closeFloater();
  1280. }
  1281. }
  1282. }
  1283. }
  1284. else
  1285. {
  1286. llwarns << "Problem saving script: " << status << llendl;
  1287. LLSD args;
  1288. args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
  1289. LLNotificationsUtil::add("SaveScriptFailReason", args);
  1290. }
  1291. delete info;
  1292. }
  1294. // static
  1295. void LLPreviewLSL::onSaveBytecodeComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
  1296. {
  1297. LLUUID* instance_uuid = (LLUUID*)user_data;
  1298. LLPreviewLSL* self = NULL;
  1299. if(instance_uuid)
  1300. {
  1301. self = LLFloaterReg::findTypedInstance<LLPreviewLSL>("preview_script", *instance_uuid);
  1302. }
  1303. if (0 == status)
  1304. {
  1305. if (self)
  1306. {
  1307. LLSD row;
  1308. row["columns"][0]["value"] = "Compile successful!";
  1309. row["columns"][0]["font"] = "SANSSERIF_SMALL";
  1310. self->mScriptEd->mErrorList->addElement(row);
  1312. // Find our window and close it if requested.
  1313. self->getWindow()->decBusyCount();
  1314. self->mPendingUploads--;
  1315. if (self->mPendingUploads <= 0
  1316. && self->mCloseAfterSave)
  1317. {
  1318. self->closeFloater();
  1319. }
  1320. }
  1321. }
  1322. else
  1323. {
  1324. llwarns << "Problem saving LSL Bytecode (Preview)" << llendl;
  1325. LLSD args;
  1326. args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
  1327. LLNotificationsUtil::add("SaveBytecodeFailReason", args);
  1328. }
  1329. delete instance_uuid;
  1330. }
  1332. // static
  1333. void LLPreviewLSL::onLoadComplete( LLVFS *vfs, const LLUUID& asset_uuid, LLAssetType::EType type,
  1334.    void* user_data, S32 status, LLExtStat ext_status)
  1335. {
  1336. lldebugs << "LLPreviewLSL::onLoadComplete: got uuid " << asset_uuid
  1337.  << llendl;
  1338. LLUUID* item_uuid = (LLUUID*)user_data;
  1339. LLPreviewLSL* preview = LLFloaterReg::findTypedInstance<LLPreviewLSL>("preview_script", *item_uuid);
  1340. if( preview )
  1341. {
  1342. if(0 == status)
  1343. {
  1344. LLVFile file(vfs, asset_uuid, type);
  1345. S32 file_length = file.getSize();
  1347. std::vector<char> buffer(file_length+1);
  1348. file.read((U8*)&buffer[0], file_length);
  1350. // put a EOS at the end
  1351. buffer[file_length] = 0;
  1352. preview->mScriptEd->setScriptText(LLStringExplicit(&buffer[0]), TRUE);
  1353. preview->mScriptEd->mEditor->makePristine();
  1354. LLInventoryItem* item = gInventory.getItem(*item_uuid);
  1355. BOOL is_modifiable = FALSE;
  1356. if(item
  1357.    && gAgent.allowOperation(PERM_MODIFY, item->getPermissions(),
  1358.     GP_OBJECT_MANIPULATE))
  1359. {
  1360. is_modifiable = TRUE;
  1361. }
  1362. preview->mScriptEd->mEditor->setEnabled(is_modifiable);
  1363. preview->mAssetStatus = PREVIEW_ASSET_LOADED;
  1364. }
  1365. else
  1366. {
  1367. LLViewerStats::getInstance()->incStat( LLViewerStats::ST_DOWNLOAD_FAILED );
  1369. if( LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE == status ||
  1370. LL_ERR_FILE_EMPTY == status)
  1371. {
  1372. LLNotificationsUtil::add("ScriptMissing");
  1373. }
  1374. else if (LL_ERR_INSUFFICIENT_PERMISSIONS == status)
  1375. {
  1376. LLNotificationsUtil::add("ScriptNoPermissions");
  1377. }
  1378. else
  1379. {
  1380. LLNotificationsUtil::add("UnableToLoadScript");
  1381. }
  1383. preview->mAssetStatus = PREVIEW_ASSET_ERROR;
  1384. llwarns << "Problem loading script: " << status << llendl;
  1385. }
  1386. }
  1387. delete item_uuid;
  1388. }
  1391. /// ---------------------------------------------------------------------------
  1392. /// LLLiveLSLEditor
  1393. /// ---------------------------------------------------------------------------
  1396. //static 
  1397. void* LLLiveLSLEditor::createScriptEdPanel(void* userdata)
  1398. {
  1400. LLLiveLSLEditor *self = (LLLiveLSLEditor*)userdata;
  1402. self->mScriptEd =  new LLScriptEdCore(
  1403.    HELLO_LSL,
  1404.    self->getHandle(),
  1405.    &LLLiveLSLEditor::onLoad,
  1406.    &LLLiveLSLEditor::onSave,
  1407.    &LLLiveLSLEditor::onSearchReplace,
  1408.    self,
  1409.    0);
  1411. return self->mScriptEd;
  1412. }
  1415. LLLiveLSLEditor::LLLiveLSLEditor(const LLSD& key) :
  1416. LLPreview(key),
  1417. mScriptEd(NULL),
  1418. mAskedForRunningInfo(FALSE),
  1419. mHaveRunningInfo(FALSE),
  1420. mCloseAfterSave(FALSE),
  1421. mPendingUploads(0),
  1422. mIsModifiable(FALSE),
  1423. mIsNew(false)
  1424. {
  1425. mFactoryMap["script ed panel"] = LLCallbackMap(LLLiveLSLEditor::createScriptEdPanel, this);
  1426. //Called from floater reg: LLUICtrlFactory::getInstance()->buildFloater(this,"floater_live_lsleditor.xml", FALSE);
  1427. }
  1429. BOOL LLLiveLSLEditor::postBuild()
  1430. {
  1431. childSetCommitCallback("running", LLLiveLSLEditor::onRunningCheckboxClicked, this);
  1432. childSetEnabled("running", FALSE);
  1434. childSetAction("Reset",&LLLiveLSLEditor::onReset,this);
  1435. childSetEnabled("Reset", TRUE);
  1437. mMonoCheckbox = getChild<LLCheckBoxCtrl>("mono");
  1438. childSetCommitCallback("mono", &LLLiveLSLEditor::onMonoCheckboxClicked, this);
  1439. childSetEnabled("mono", FALSE);
  1441. mScriptEd->mEditor->makePristine();
  1442. mScriptEd->mEditor->setFocus(TRUE);
  1444. return LLPreview::postBuild();
  1445. }
  1447. LLLiveLSLEditor::~LLLiveLSLEditor()
  1448. {
  1449. }
  1451. // virtual
  1452. void LLLiveLSLEditor::callbackLSLCompileSucceeded(const LLUUID& task_id,
  1453.   const LLUUID& item_id,
  1454.   bool is_script_running)
  1455. {
  1456. lldebugs << "LSL Bytecode saved" << llendl;
  1457. mScriptEd->mErrorList->setCommentText(LLTrans::getString("CompileSuccessful"));
  1458. mScriptEd->mErrorList->setCommentText(LLTrans::getString("SaveComplete"));
  1459. closeIfNeeded();
  1460. }
  1462. // virtual
  1463. void LLLiveLSLEditor::callbackLSLCompileFailed(const LLSD& compile_errors)
  1464. {
  1465. lldebugs << "Compile failed!" << llendl;
  1466. for(LLSD::array_const_iterator line = compile_errors.beginArray();
  1467. line < compile_errors.endArray();
  1468. line++)
  1469. {
  1470. LLSD row;
  1471. std::string error_message = line->asString();
  1472. LLStringUtil::stripNonprintable(error_message);
  1473. row["columns"][0]["value"] = error_message;
  1474. // *TODO: change to "MONOSPACE" and change llfontgl.cpp?
  1475. row["columns"][0]["font"] = "OCRA";
  1476. mScriptEd->mErrorList->addElement(row);
  1477. }
  1478. mScriptEd->selectFirstError();
  1479. closeIfNeeded();
  1480. }
  1482. void LLLiveLSLEditor::loadAsset()
  1483. {
  1484. //llinfos << "LLLiveLSLEditor::loadAsset()" << llendl;
  1485. if(!mIsNew)
  1486. {
  1487. LLViewerObject* object = gObjectList.findObject(mObjectUUID);
  1488. if(object)
  1489. {
  1490. LLViewerInventoryItem* item = dynamic_cast<LLViewerInventoryItem*>(object->getInventoryObject(mItemUUID));
  1491. if(item 
  1492. && (gAgent.allowOperation(PERM_COPY, item->getPermissions(), GP_OBJECT_MANIPULATE)
  1493.    || gAgent.isGodlike()))
  1494. {
  1495. mItem = new LLViewerInventoryItem(item);
  1496. //llinfos << "asset id " << mItem->getAssetUUID() << llendl;
  1497. }
  1499. if(!gAgent.isGodlike()
  1500.    && (item
  1501.    && (!gAgent.allowOperation(PERM_COPY, item->getPermissions(), GP_OBJECT_MANIPULATE)
  1502.    || !gAgent.allowOperation(PERM_MODIFY, item->getPermissions(), GP_OBJECT_MANIPULATE))))
  1503. {
  1504. mItem = new LLViewerInventoryItem(item);
  1505. mScriptEd->setScriptText(getString("not_allowed"), FALSE);
  1506. mScriptEd->mEditor->makePristine();
  1507. mScriptEd->mEditor->setEnabled(FALSE);
  1508. mScriptEd->enableSave(FALSE);
  1509. mAssetStatus = PREVIEW_ASSET_LOADED;
  1510. }
  1511. else if(item && mItem.notNull())
  1512. {
  1513. // request the text from the object
  1514. LLUUID* user_data = new LLUUID(mItemUUID); //  ^ mObjectUUID
  1515. gAssetStorage->getInvItemAsset(object->getRegion()->getHost(),
  1516.    gAgent.getID(),
  1517.    gAgent.getSessionID(),
  1518.    item->getPermissions().getOwner(),
  1519.    object->getID(),
  1520.    item->getUUID(),
  1521.    item->getAssetUUID(),
  1522.    item->getType(),
  1523.    &LLLiveLSLEditor::onLoadComplete,
  1524.    (void*)user_data,
  1525.    TRUE);
  1526. LLMessageSystem* msg = gMessageSystem;
  1527. msg->newMessageFast(_PREHASH_GetScriptRunning);
  1528. msg->nextBlockFast(_PREHASH_Script);
  1529. msg->addUUIDFast(_PREHASH_ObjectID, mObjectUUID);
  1530. msg->addUUIDFast(_PREHASH_ItemID, mItemUUID);
  1531. msg->sendReliable(object->getRegion()->getHost());
  1532. mAskedForRunningInfo = TRUE;
  1533. mAssetStatus = PREVIEW_ASSET_LOADING;
  1534. }
  1535. else
  1536. {
  1537. mScriptEd->setScriptText(LLStringUtil::null, FALSE);
  1538. mScriptEd->mEditor->makePristine();
  1539. mAssetStatus = PREVIEW_ASSET_LOADED;
  1540. }
  1542. mIsModifiable = item && gAgent.allowOperation(PERM_MODIFY, 
  1543. item->getPermissions(),
  1544.     GP_OBJECT_MANIPULATE);
  1545. if(!mIsModifiable)
  1546. {
  1547. mScriptEd->mEditor->setEnabled(FALSE);
  1548. }
  1550. // This is commented out, because we don't completely
  1551. // handle script exports yet.
  1552. /*
  1553. // request the exports from the object
  1554. gMessageSystem->newMessage("GetScriptExports");
  1555. gMessageSystem->nextBlock("ScriptBlock");
  1556. gMessageSystem->addUUID("AgentID", gAgent.getID());
  1557. U32 local_id = object->getLocalID();
  1558. gMessageSystem->addData("LocalID", &local_id);
  1559. gMessageSystem->addUUID("ItemID", mItemUUID);
  1560. LLHost host(object->getRegion()->getIP(),
  1561. object->getRegion()->getPort());
  1562. gMessageSystem->sendReliable(host);
  1563. */
  1564. }
  1565. }
  1566. else
  1567. {
  1568. mScriptEd->setScriptText(std::string(HELLO_LSL), TRUE);
  1569. mScriptEd->enableSave(FALSE);
  1570. LLPermissions perm;
  1571. perm.init(gAgent.getID(), gAgent.getID(), LLUUID::null, gAgent.getGroupID());
  1572. perm.initMasks(PERM_ALL, PERM_ALL, PERM_NONE, PERM_NONE, PERM_MOVE | PERM_TRANSFER);
  1573. mItem = new LLViewerInventoryItem(mItemUUID,
  1574.   mObjectUUID,
  1575.   perm,
  1576.   LLUUID::null,
  1577.   LLAssetType::AT_LSL_TEXT,
  1578.   LLInventoryType::IT_LSL,
  1579.   DEFAULT_SCRIPT_NAME,
  1580.   DEFAULT_SCRIPT_DESC,
  1581.   LLSaleInfo::DEFAULT,
  1582.   LLInventoryItem::II_FLAGS_NONE,
  1583.   time_corrected());
  1584. mAssetStatus = PREVIEW_ASSET_LOADED;
  1585. }
  1586. }
  1588. // static
  1589. void LLLiveLSLEditor::onLoadComplete(LLVFS *vfs, const LLUUID& asset_id,
  1590.  LLAssetType::EType type,
  1591.  void* user_data, S32 status, LLExtStat ext_status)
  1592. {
  1593. lldebugs << "LLLiveLSLEditor::onLoadComplete: got uuid " << asset_id
  1594.  << llendl;
  1595. LLUUID* xored_id = (LLUUID*)user_data;
  1597. LLLiveLSLEditor* instance = LLFloaterReg::findTypedInstance<LLLiveLSLEditor>("preview_scriptedit", *xored_id);
  1599. if(instance )
  1600. {
  1601. if( LL_ERR_NOERR == status )
  1602. {
  1603. instance->loadScriptText(vfs, asset_id, type);
  1604. instance->mAssetStatus = PREVIEW_ASSET_LOADED;
  1605. }
  1606. else
  1607. {
  1608. LLViewerStats::getInstance()->incStat( LLViewerStats::ST_DOWNLOAD_FAILED );
  1610. if( LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE == status ||
  1611. LL_ERR_FILE_EMPTY == status)
  1612. {
  1613. LLNotificationsUtil::add("ScriptMissing");
  1614. }
  1615. else if (LL_ERR_INSUFFICIENT_PERMISSIONS == status)
  1616. {
  1617. LLNotificationsUtil::add("ScriptNoPermissions");
  1618. }
  1619. else
  1620. {
  1621. LLNotificationsUtil::add("UnableToLoadScript");
  1622. }
  1623. instance->mAssetStatus = PREVIEW_ASSET_ERROR;
  1624. }
  1625. }
  1627. delete xored_id;
  1628. }
  1630. // unused
  1631. // void LLLiveLSLEditor::loadScriptText(const std::string& filename)
  1632. // {
  1633. //  if(!filename)
  1634. //  {
  1635. //  llerrs << "Filename is Empty!" << llendl;
  1636. //  return;
  1637. //  }
  1638. //  LLFILE* file = LLFile::fopen(filename, "rb"); /*Flawfinder: ignore*/
  1639. //  if(file)
  1640. //  {
  1641. //  // read in the whole file
  1642. //  fseek(file, 0L, SEEK_END);
  1643. //  long file_length = ftell(file);
  1644. //  fseek(file, 0L, SEEK_SET);
  1645. //  char* buffer = new char[file_length+1];
  1646. //  size_t nread = fread(buffer, 1, file_length, file);
  1647. //  if (nread < (size_t) file_length)
  1648. //  {
  1649. //  llwarns << "Short read" << llendl;
  1650. //  }
  1651. //  buffer[nread] = '';
  1652. //  fclose(file);
  1653. //  mScriptEd->mEditor->setText(LLStringExplicit(buffer));
  1654. //  mScriptEd->mEditor->makePristine();
  1655. //  delete[] buffer;
  1656. //  }
  1657. //  else
  1658. //  {
  1659. //  llwarns << "Error opening " << filename << llendl;
  1660. //  }
  1661. // }
  1663. void LLLiveLSLEditor::loadScriptText(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
  1664. {
  1665. LLVFile file(vfs, uuid, type);
  1666. S32 file_length = file.getSize();
  1667. std::vector<char> buffer(file_length + 1);
  1668. file.read((U8*)&buffer[0], file_length);
  1670. if (file.getLastBytesRead() != file_length ||
  1671. file_length <= 0)
  1672. {
  1673. llwarns << "Error reading " << uuid << ":" << type << llendl;
  1674. }
  1676. buffer[file_length] = '';
  1678. mScriptEd->setScriptText(LLStringExplicit(&buffer[0]), TRUE);
  1679. mScriptEd->mEditor->makePristine();
  1680. }
  1683. void LLLiveLSLEditor::onRunningCheckboxClicked( LLUICtrl*, void* userdata )
  1684. {
  1685. LLLiveLSLEditor* self = (LLLiveLSLEditor*) userdata;
  1686. LLViewerObject* object = gObjectList.findObject( self->mObjectUUID );
  1687. LLCheckBoxCtrl* runningCheckbox = self->getChild<LLCheckBoxCtrl>("running");
  1688. BOOL running =  runningCheckbox->get();
  1689. //self->mRunningCheckbox->get();
  1690. if( object )
  1691. {
  1692. LLMessageSystem* msg = gMessageSystem;
  1693. msg->newMessageFast(_PREHASH_SetScriptRunning);
  1694. msg->nextBlockFast(_PREHASH_AgentData);
  1695. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1696. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1697. msg->nextBlockFast(_PREHASH_Script);
  1698. msg->addUUIDFast(_PREHASH_ObjectID, self->mObjectUUID);
  1699. msg->addUUIDFast(_PREHASH_ItemID, self->mItemUUID);
  1700. msg->addBOOLFast(_PREHASH_Running, running);
  1701. msg->sendReliable(object->getRegion()->getHost());
  1702. }
  1703. else
  1704. {
  1705. runningCheckbox->set(!running);
  1706. LLNotificationsUtil::add("CouldNotStartStopScript");
  1707. }
  1708. }
  1710. void LLLiveLSLEditor::onReset(void *userdata)
  1711. {
  1712. LLLiveLSLEditor* self = (LLLiveLSLEditor*) userdata;
  1714. LLViewerObject* object = gObjectList.findObject( self->mObjectUUID );
  1715. if(object)
  1716. {
  1717. LLMessageSystem* msg = gMessageSystem;
  1718. msg->newMessageFast(_PREHASH_ScriptReset);
  1719. msg->nextBlockFast(_PREHASH_AgentData);
  1720. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1721. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1722. msg->nextBlockFast(_PREHASH_Script);
  1723. msg->addUUIDFast(_PREHASH_ObjectID, self->mObjectUUID);
  1724. msg->addUUIDFast(_PREHASH_ItemID, self->mItemUUID);
  1725. msg->sendReliable(object->getRegion()->getHost());
  1726. }
  1727. else
  1728. {
  1729. LLNotificationsUtil::add("CouldNotStartStopScript"); 
  1730. }
  1731. }
  1733. void LLLiveLSLEditor::draw()
  1734. {
  1735. LLViewerObject* object = gObjectList.findObject(mObjectUUID);
  1736. LLCheckBoxCtrl* runningCheckbox = getChild<LLCheckBoxCtrl>( "running");
  1737. if(object && mAskedForRunningInfo && mHaveRunningInfo)
  1738. {
  1739. if(object->permAnyOwner())
  1740. {
  1741. runningCheckbox->setLabel(getString("script_running"));
  1742. runningCheckbox->setEnabled(TRUE);
  1744. if(object->permAnyOwner())
  1745. {
  1746. runningCheckbox->setLabel(getString("script_running"));
  1747. runningCheckbox->setEnabled(TRUE);
  1748. }
  1749. else
  1750. {
  1751. runningCheckbox->setLabel(getString("public_objects_can_not_run"));
  1752. runningCheckbox->setEnabled(FALSE);
  1753. // *FIX: Set it to false so that the ui is correct for
  1754. // a box that is released to public. It could be
  1755. // incorrect after a release/claim cycle, but will be
  1756. // correct after clicking on it.
  1757. runningCheckbox->set(FALSE);
  1758. mMonoCheckbox->set(FALSE);
  1759. }
  1760. }
  1761. else
  1762. {
  1763. runningCheckbox->setLabel(getString("public_objects_can_not_run"));
  1764. runningCheckbox->setEnabled(FALSE);
  1766. // *FIX: Set it to false so that the ui is correct for
  1767. // a box that is released to public. It could be
  1768. // incorrect after a release/claim cycle, but will be
  1769. // correct after clicking on it.
  1770. runningCheckbox->set(FALSE);
  1771. mMonoCheckbox->setEnabled(FALSE);
  1772. // object may have fallen out of range.
  1773. mHaveRunningInfo = FALSE;
  1774. }
  1775. }
  1776. else if(!object)
  1777. {
  1778. // HACK: Display this information in the title bar.
  1779. // Really ought to put in main window.
  1780. setTitle(LLTrans::getString("ObjectOutOfRange"));
  1781. runningCheckbox->setEnabled(FALSE);
  1782. // object may have fallen out of range.
  1783. mHaveRunningInfo = FALSE;
  1784. }
  1786. LLPreview::draw();
  1787. }
  1790. void LLLiveLSLEditor::onSearchReplace(void* userdata)
  1791. {
  1792. LLLiveLSLEditor* self = (LLLiveLSLEditor*)userdata;
  1794. LLScriptEdCore* sec = self->mScriptEd; 
  1795. LLFloaterScriptSearch::show(sec);
  1796. }
  1798. struct LLLiveLSLSaveData
  1799. {
  1800. LLLiveLSLSaveData(const LLUUID& id, const LLViewerInventoryItem* item, BOOL active);
  1801. LLUUID mSaveObjectID;
  1802. LLPointer<LLViewerInventoryItem> mItem;
  1803. BOOL mActive;
  1804. };
  1806. LLLiveLSLSaveData::LLLiveLSLSaveData(const LLUUID& id,
  1807.  const LLViewerInventoryItem* item,
  1808.  BOOL active) :
  1809. mSaveObjectID(id),
  1810. mActive(active)
  1811. {
  1812. llassert(item);
  1813. mItem = new LLViewerInventoryItem(item);
  1814. }
  1816. void LLLiveLSLEditor::saveIfNeeded()
  1817. {
  1818. llinfos << "LLLiveLSLEditor::saveIfNeeded()" << llendl;
  1819. LLViewerObject* object = gObjectList.findObject(mObjectUUID);
  1820. if(!object)
  1821. {
  1822. LLNotificationsUtil::add("SaveScriptFailObjectNotFound");
  1823. return;
  1824. }
  1826. if(mItem.isNull() || !mItem->isComplete())
  1827. {
  1828. // $NOTE: While the error message may not be exactly correct,
  1829. // it's pretty close.
  1830. LLNotificationsUtil::add("SaveScriptFailObjectNotFound");
  1831. return;
  1832. }
  1834. // get the latest info about it. We used to be losing the script
  1835. // name on save, because the viewer object version of the item,
  1836. // and the editor version would get out of synch. Here's a good
  1837. // place to synch them back up.
  1838. LLInventoryItem* inv_item = dynamic_cast<LLInventoryItem*>(object->getInventoryObject(mItemUUID));
  1839. if(inv_item)
  1840. {
  1841. mItem->copyItem(inv_item);
  1842. }
  1844. // Don't need to save if we're pristine
  1845. if(!mScriptEd->hasChanged())
  1846. {
  1847. return;
  1848. }
  1850. mPendingUploads = 0;
  1852. // save the script
  1853. mScriptEd->enableSave(FALSE);
  1854. mScriptEd->mEditor->makePristine();
  1855. mScriptEd->mErrorList->deleteAllItems();
  1857. // set up the save on the local machine.
  1858. mScriptEd->mEditor->makePristine();
  1859. LLTransactionID tid;
  1860. tid.generate();
  1861. LLAssetID asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
  1862. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,asset_id.asString());
  1863. std::string filename = llformat("%s.lsl", filepath.c_str());
  1865. mItem->setAssetUUID(asset_id);
  1866. mItem->setTransactionID(tid);
  1868. // write out the data, and store it in the asset database
  1869. LLFILE* fp = LLFile::fopen(filename, "wb");
  1870. if(!fp)
  1871. {
  1872. llwarns << "Unable to write to " << filename << llendl;
  1874. LLSD row;
  1875. row["columns"][0]["value"] = "Error writing to local file. Is your hard drive full?";
  1876. row["columns"][0]["font"] = "SANSSERIF_SMALL";
  1877. mScriptEd->mErrorList->addElement(row);
  1878. return;
  1879. }
  1880. std::string utf8text = mScriptEd->mEditor->getText();
  1882. // Special case for a completely empty script - stuff in one space so it can store properly.  See SL-46889
  1883. if ( utf8text.size() == 0 )
  1884. {
  1885. utf8text = " ";
  1886. }
  1888. fputs(utf8text.c_str(), fp);
  1889. fclose(fp);
  1890. fp = NULL;
  1892. // save it out to asset server
  1893. std::string url = object->getRegion()->getCapability("UpdateScriptTask");
  1894. getWindow()->incBusyCount();
  1895. mPendingUploads++;
  1896. BOOL is_running = getChild<LLCheckBoxCtrl>( "running")->get();
  1897. if (!url.empty())
  1898. {
  1899. uploadAssetViaCaps(url, filename, mObjectUUID, mItemUUID, is_running);
  1900. }
  1901. else if (gAssetStorage)
  1902. {
  1903. uploadAssetLegacy(filename, object, tid, is_running);
  1904. }
  1905. }
  1907. void LLLiveLSLEditor::uploadAssetViaCaps(const std::string& url,
  1908.  const std::string& filename,
  1909.  const LLUUID& task_id,
  1910.  const LLUUID& item_id,
  1911.  BOOL is_running)
  1912. {
  1913. llinfos << "Update Task Inventory via capability " << url << llendl;
  1914. LLSD body;
  1915. body["task_id"] = task_id;
  1916. body["item_id"] = item_id;
  1917. body["is_script_running"] = is_running;
  1918. body["target"] = monoChecked() ? "mono" : "lsl2";
  1919. LLHTTPClient::post(url, body,
  1920. new LLUpdateTaskInventoryResponder(body, filename, LLAssetType::AT_LSL_TEXT));
  1921. }
  1923. void LLLiveLSLEditor::uploadAssetLegacy(const std::string& filename,
  1924. LLViewerObject* object,
  1925. const LLTransactionID& tid,
  1926. BOOL is_running)
  1927. {
  1928. LLLiveLSLSaveData* data = new LLLiveLSLSaveData(mObjectUUID,
  1929. mItem,
  1930. is_running);
  1931. gAssetStorage->storeAssetData(filename, tid,
  1932.   LLAssetType::AT_LSL_TEXT,
  1933.   &onSaveTextComplete,
  1934.   (void*)data,
  1935.   FALSE);
  1937. LLAssetID asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
  1938. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,asset_id.asString());
  1939. std::string dst_filename = llformat("%s.lso", filepath.c_str());
  1940. std::string err_filename = llformat("%s.out", filepath.c_str());
  1942. LLFILE *fp;
  1943. const BOOL compile_to_mono = FALSE;
  1944. if(!lscript_compile(filename.c_str(),
  1945. dst_filename.c_str(),
  1946. err_filename.c_str(),
  1947. compile_to_mono,
  1948. asset_id.asString().c_str(),
  1949. gAgent.isGodlike()))
  1950. {
  1951. // load the error file into the error scrolllist
  1952. llinfos << "Compile failed!" << llendl;
  1953. if(NULL != (fp = LLFile::fopen(err_filename, "r")))
  1954. {
  1955. char buffer[MAX_STRING]; /*Flawfinder: ignore*/
  1956. std::string line;
  1957. while(!feof(fp)) 
  1958. {
  1960. if (fgets(buffer, MAX_STRING, fp) == NULL)
  1961. {
  1962. buffer[0] = '';
  1963. }
  1964. if(feof(fp))
  1965. {
  1966. break;
  1967. }
  1968. else
  1969. {
  1970. line.assign(buffer);
  1971. LLStringUtil::stripNonprintable(line);
  1973. LLSD row;
  1974. row["columns"][0]["value"] = line;
  1975. row["columns"][0]["font"] = "OCRA";
  1976. mScriptEd->mErrorList->addElement(row);
  1977. }
  1978. }
  1979. fclose(fp);
  1980. mScriptEd->selectFirstError();
  1981. // don't set the asset id, because we want to save the
  1982. // script, even though the compile failed.
  1983. //mItem->setAssetUUID(LLUUID::null);
  1984. object->saveScript(mItem, FALSE, false);
  1985. dialog_refresh_all();
  1986. }
  1987. }
  1988. else
  1989. {
  1990. llinfos << "Compile worked!" << llendl;
  1991. mScriptEd->mErrorList->setCommentText(LLTrans::getString("CompileSuccessfulSaving"));
  1992. if(gAssetStorage)
  1993. {
  1994. llinfos << "LLLiveLSLEditor::saveAsset "
  1995. << mItem->getAssetUUID() << llendl;
  1996. getWindow()->incBusyCount();
  1997. mPendingUploads++;
  1998. LLLiveLSLSaveData* data = NULL;
  1999. data = new LLLiveLSLSaveData(mObjectUUID,
  2000.  mItem,
  2001.  is_running);
  2002. gAssetStorage->storeAssetData(dst_filename,
  2003.   tid,
  2004.   LLAssetType::AT_LSL_BYTECODE,
  2005.   &LLLiveLSLEditor::onSaveBytecodeComplete,
  2006.   (void*)data);
  2007. dialog_refresh_all();
  2008. }
  2009. }
  2011. // get rid of any temp files left lying around
  2012. LLFile::remove(filename);
  2013. LLFile::remove(err_filename);
  2014. LLFile::remove(dst_filename);
  2016. // If we successfully saved it, then we should be able to check/uncheck the running box!
  2017. LLCheckBoxCtrl* runningCheckbox = getChild<LLCheckBoxCtrl>( "running");
  2018. runningCheckbox->setLabel(getString("script_running"));
  2019. runningCheckbox->setEnabled(TRUE);
  2020. }
  2022. void LLLiveLSLEditor::onSaveTextComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
  2023. {
  2024. LLLiveLSLSaveData* data = (LLLiveLSLSaveData*)user_data;
  2026. if (status)
  2027. {
  2028. llwarns << "Unable to save text for a script." << llendl;
  2029. LLSD args;
  2030. args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
  2031. LLNotificationsUtil::add("CompileQueueSaveText", args);
  2032. }
  2033. else
  2034. {
  2035. LLLiveLSLEditor* self = LLFloaterReg::findTypedInstance<LLLiveLSLEditor>("preview_scriptedit", data->mItem->getUUID()); //  ^ data->mSaveObjectID
  2036. if (self)
  2037. {
  2038. self->getWindow()->decBusyCount();
  2039. self->mPendingUploads--;
  2040. if (self->mPendingUploads <= 0
  2041. && self->mCloseAfterSave)
  2042. {
  2043. self->closeFloater();
  2044. }
  2045. }
  2046. }
  2047. delete data;
  2048. data = NULL;
  2049. }
  2052. void LLLiveLSLEditor::onSaveBytecodeComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
  2053. {
  2054. LLLiveLSLSaveData* data = (LLLiveLSLSaveData*)user_data;
  2055. if(!data)
  2056. return;
  2057. if(0 ==status)
  2058. {
  2059. llinfos << "LSL Bytecode saved" << llendl;
  2060. LLLiveLSLEditor* self = LLFloaterReg::findTypedInstance<LLLiveLSLEditor>("preview_scriptedit", data->mItem->getUUID()); //  ^ data->mSaveObjectID
  2061. if (self)
  2062. {
  2063. // Tell the user that the compile worked.
  2064. self->mScriptEd->mErrorList->setCommentText(LLTrans::getString("SaveComplete"));
  2065. // close the window if this completes both uploads
  2066. self->getWindow()->decBusyCount();
  2067. self->mPendingUploads--;
  2068. if (self->mPendingUploads <= 0
  2069. && self->mCloseAfterSave)
  2070. {
  2071. self->closeFloater();
  2072. }
  2073. }
  2074. LLViewerObject* object = gObjectList.findObject(data->mSaveObjectID);
  2075. if(object)
  2076. {
  2077. object->saveScript(data->mItem, data->mActive, false);
  2078. dialog_refresh_all();
  2079. //LLToolDragAndDrop::dropScript(object, ids->first,
  2080. //   LLAssetType::AT_LSL_TEXT, FALSE);
  2081. }
  2082. }
  2083. else
  2084. {
  2085. llinfos << "Problem saving LSL Bytecode (Live Editor)" << llendl;
  2086. llwarns << "Unable to save a compiled script." << llendl;
  2088. LLSD args;
  2089. args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
  2090. LLNotificationsUtil::add("CompileQueueSaveBytecode", args);
  2091. }
  2093. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,asset_uuid.asString());
  2094. std::string dst_filename = llformat("%s.lso", filepath.c_str());
  2095. LLFile::remove(dst_filename);
  2096. delete data;
  2097. }
  2099. BOOL LLLiveLSLEditor::canClose()
  2100. {
  2101. return (mScriptEd->canClose());
  2102. }
  2104. void LLLiveLSLEditor::closeIfNeeded()
  2105. {
  2106. getWindow()->decBusyCount();
  2107. mPendingUploads--;
  2108. if (mPendingUploads <= 0 && mCloseAfterSave)
  2109. {
  2110. closeFloater();
  2111. }
  2112. }
  2114. // static
  2115. void LLLiveLSLEditor::onLoad(void* userdata)
  2116. {
  2117. LLLiveLSLEditor* self = (LLLiveLSLEditor*)userdata;
  2118. self->loadAsset();
  2119. }
  2121. // static
  2122. void LLLiveLSLEditor::onSave(void* userdata, BOOL close_after_save)
  2123. {
  2124. LLLiveLSLEditor* self = (LLLiveLSLEditor*)userdata;
  2125. self->mCloseAfterSave = close_after_save;
  2126. self->saveIfNeeded();
  2127. }
  2129. // static
  2130. void LLLiveLSLEditor::processScriptRunningReply(LLMessageSystem* msg, void**)
  2131. {
  2132. LLUUID item_id;
  2133. LLUUID object_id;
  2134. msg->getUUIDFast(_PREHASH_Script, _PREHASH_ObjectID, object_id);
  2135. msg->getUUIDFast(_PREHASH_Script, _PREHASH_ItemID, item_id);
  2137. LLLiveLSLEditor* instance = LLFloaterReg::findTypedInstance<LLLiveLSLEditor>("preview_scriptedit", item_id); //  ^ object_id
  2138. if(instance)
  2139. {
  2140. instance->mHaveRunningInfo = TRUE;
  2141. BOOL running;
  2142. msg->getBOOLFast(_PREHASH_Script, _PREHASH_Running, running);
  2143. LLCheckBoxCtrl* runningCheckbox = instance->getChild<LLCheckBoxCtrl>("running");
  2144. runningCheckbox->set(running);
  2145. BOOL mono;
  2146. msg->getBOOLFast(_PREHASH_Script, "Mono", mono);
  2147. LLCheckBoxCtrl* monoCheckbox = instance->getChild<LLCheckBoxCtrl>("mono");
  2148. monoCheckbox->setEnabled(instance->getIsModifiable() && have_script_upload_cap(object_id));
  2149. monoCheckbox->set(mono);
  2150. }
  2151. }
  2154. void LLLiveLSLEditor::onMonoCheckboxClicked(LLUICtrl*, void* userdata)
  2155. {
  2156. LLLiveLSLEditor* self = static_cast<LLLiveLSLEditor*>(userdata);
  2157. self->mMonoCheckbox->setEnabled(have_script_upload_cap(self->mObjectUUID));
  2158. self->mScriptEd->enableSave(self->getIsModifiable());
  2159. }
  2161. BOOL LLLiveLSLEditor::monoChecked() const
  2162. {
  2163. if(NULL != mMonoCheckbox)
  2164. {
  2165. return mMonoCheckbox->getValue()? TRUE : FALSE;
  2166. }
  2167. return FALSE;
  2168. }