00001
00032 #include "llviewerprecompiledheaders.h"
00033
00034 #include "llfloatergodtools.h"
00035
00036 #include "llcoord.h"
00037 #include "llfontgl.h"
00038 #include "llframetimer.h"
00039 #include "llgl.h"
00040 #include "llhost.h"
00041 #include "llregionflags.h"
00042 #include "llstring.h"
00043 #include "message.h"
00044
00045 #include "llagent.h"
00046 #include "llalertdialog.h"
00047 #include "llbutton.h"
00048 #include "llcheckboxctrl.h"
00049 #include "llcombobox.h"
00050 #include "lldraghandle.h"
00051 #include "llfloater.h"
00052 #include "llfocusmgr.h"
00053 #include "llfloatertopobjects.h"
00054 #include "lllineeditor.h"
00055 #include "llmenugl.h"
00056 #include "llresmgr.h"
00057 #include "llselectmgr.h"
00058 #include "llsky.h"
00059 #include "llspinctrl.h"
00060 #include "llstatusbar.h"
00061 #include "lltabcontainer.h"
00062 #include "lltextbox.h"
00063 #include "lluictrl.h"
00064 #include "llviewerparcelmgr.h"
00065 #include "llviewerregion.h"
00066 #include "llviewerwindow.h"
00067 #include "llworld.h"
00068 #include "llfloateravatarpicker.h"
00069 #include "llnotify.h"
00070 #include "llxfermanager.h"
00071 #include "llvlcomposition.h"
00072 #include "llsurface.h"
00073 #include "llviewercontrol.h"
00074 #include "lluictrlfactory.h"
00075
00076 #include "lltransfertargetfile.h"
00077 #include "lltransfersourcefile.h"
00078
00079 const F32 SECONDS_BETWEEN_UPDATE_REQUESTS = 5.0f;
00080
00081 static LLFloaterGodTools* sGodTools = NULL;
00082
00083
00084
00085
00086
00087
00088 LLFloaterGodTools* LLFloaterGodTools::instance()
00089 {
00090 if (!sGodTools)
00091 {
00092 sGodTools = new LLFloaterGodTools();
00093 sGodTools->open();
00094 sGodTools->center();
00095 sGodTools->setFocus(TRUE);
00096 }
00097 return sGodTools;
00098 }
00099
00100
00101
00102 void LLFloaterGodTools::refreshAll()
00103 {
00104 LLFloaterGodTools* god_tools = instance();
00105 if (god_tools)
00106 {
00107 if (gAgent.getRegionHost() != god_tools->mCurrentHost)
00108 {
00109
00110 god_tools->sendRegionInfoRequest();
00111 }
00112 }
00113 }
00114
00115
00116
00117 LLFloaterGodTools::LLFloaterGodTools()
00118 : LLFloater("godtools floater"),
00119 mCurrentHost(LLHost::invalid),
00120 mUpdateTimer()
00121 {
00122 LLCallbackMap::map_t factory_map;
00123 factory_map["grid"] = LLCallbackMap(createPanelGrid, this);
00124 factory_map["region"] = LLCallbackMap(createPanelRegion, this);
00125 factory_map["objects"] = LLCallbackMap(createPanelObjects, this);
00126 factory_map["request"] = LLCallbackMap(createPanelRequest, this);
00127 LLUICtrlFactory::getInstance()->buildFloater(this, "floater_god_tools.xml", &factory_map);
00128
00129 childSetTabChangeCallback("GodTools Tabs", "grid", onTabChanged, this);
00130 childSetTabChangeCallback("GodTools Tabs", "region", onTabChanged, this);
00131 childSetTabChangeCallback("GodTools Tabs", "objects", onTabChanged, this);
00132 childSetTabChangeCallback("GodTools Tabs", "request", onTabChanged, this);
00133
00134 sendRegionInfoRequest();
00135
00136 childShowTab("GodTools Tabs", "region");
00137 }
00138
00139
00140 void* LLFloaterGodTools::createPanelGrid(void *userdata)
00141 {
00142 return new LLPanelGridTools("grid");
00143 }
00144
00145
00146 void* LLFloaterGodTools::createPanelRegion(void *userdata)
00147 {
00148 LLFloaterGodTools* self = (LLFloaterGodTools*)userdata;
00149 self->mPanelRegionTools = new LLPanelRegionTools("region");
00150 return self->mPanelRegionTools;
00151 }
00152
00153
00154 void* LLFloaterGodTools::createPanelObjects(void *userdata)
00155 {
00156 LLFloaterGodTools* self = (LLFloaterGodTools*)userdata;
00157 self->mPanelObjectTools = new LLPanelObjectTools("objects");
00158 return self->mPanelObjectTools;
00159 }
00160
00161
00162 void* LLFloaterGodTools::createPanelRequest(void *userdata)
00163 {
00164 return new LLPanelRequestTools("region");
00165 }
00166
00167 LLFloaterGodTools::~LLFloaterGodTools()
00168 {
00169
00170 }
00171
00172 U32 LLFloaterGodTools::computeRegionFlags() const
00173 {
00174 U32 flags = gAgent.getRegion()->getRegionFlags();
00175 if (mPanelRegionTools) flags = mPanelRegionTools->computeRegionFlags(flags);
00176 if (mPanelObjectTools) flags = mPanelObjectTools->computeRegionFlags(flags);
00177 return flags;
00178 }
00179
00180
00181 void LLFloaterGodTools::updatePopup(LLCoordGL center, MASK mask)
00182 {
00183 }
00184
00185
00186 void LLFloaterGodTools::onClose(bool app_quitting)
00187 {
00188 if (sGodTools)
00189 {
00190 sGodTools->setVisible(FALSE);
00191 }
00192 }
00193
00194
00195 void LLFloaterGodTools::draw()
00196 {
00197 if (mCurrentHost == LLHost::invalid)
00198 {
00199 if (mUpdateTimer.getElapsedTimeF32() > SECONDS_BETWEEN_UPDATE_REQUESTS)
00200 {
00201 sendRegionInfoRequest();
00202 }
00203 }
00204 else if (gAgent.getRegionHost() != mCurrentHost)
00205 {
00206 sendRegionInfoRequest();
00207 }
00208 LLFloater::draw();
00209 }
00210
00211
00212 void LLFloaterGodTools::show(void *)
00213 {
00214 LLFloaterGodTools* god_tools = instance();
00215 god_tools->open();
00216 LLPanel *panel = god_tools->childGetVisibleTab("GodTools Tabs");
00217 if (panel) panel->setFocus(TRUE);
00218 if (god_tools->mPanelObjectTools) god_tools->mPanelObjectTools->setTargetAvatar(LLUUID::null);
00219
00220 if (gAgent.getRegionHost() != god_tools->mCurrentHost)
00221 {
00222
00223 god_tools->sendRegionInfoRequest();
00224 }
00225 }
00226
00227 void LLFloaterGodTools::showPanel(const LLString& panel_name)
00228 {
00229 childShowTab("GodTools Tabs", panel_name);
00230 open();
00231 LLPanel *panel = childGetVisibleTab("GodTools Tabs");
00232 if (panel) panel->setFocus(TRUE);
00233 }
00234
00235
00236
00237 void LLFloaterGodTools::onTabChanged(void* data, bool from_click)
00238 {
00239 LLPanel* panel = (LLPanel*)data;
00240 if (panel)
00241 {
00242 panel->setFocus(TRUE);
00243 }
00244 }
00245
00246
00247
00248 void LLFloaterGodTools::processRegionInfo(LLMessageSystem* msg)
00249 {
00250 LLHost host = msg->getSender();
00251 if (host != gAgent.getRegionHost())
00252 {
00253
00254 return;
00255 }
00256
00257
00258 U32 region_flags;
00259 U8 sim_access;
00260 U8 agent_limit;
00261 char sim_name[MAX_STRING];
00262 U32 estate_id;
00263 U32 parent_estate_id;
00264 F32 water_height;
00265 F32 billable_factor;
00266 F32 object_bonus_factor;
00267 F32 terrain_raise_limit;
00268 F32 terrain_lower_limit;
00269 S32 price_per_meter;
00270 S32 redirect_grid_x;
00271 S32 redirect_grid_y;
00272 LLUUID cache_id;
00273
00274 msg->getStringFast(_PREHASH_RegionInfo, _PREHASH_SimName, MAX_STRING, sim_name);
00275 msg->getU32Fast(_PREHASH_RegionInfo, _PREHASH_EstateID, estate_id);
00276 msg->getU32Fast(_PREHASH_RegionInfo, _PREHASH_ParentEstateID, parent_estate_id);
00277 msg->getU32Fast(_PREHASH_RegionInfo, _PREHASH_RegionFlags, region_flags);
00278 msg->getU8Fast(_PREHASH_RegionInfo, _PREHASH_SimAccess, sim_access);
00279 msg->getU8Fast(_PREHASH_RegionInfo, _PREHASH_MaxAgents, agent_limit);
00280 msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_ObjectBonusFactor, object_bonus_factor);
00281 msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_BillableFactor, billable_factor);
00282 msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_WaterHeight, water_height);
00283 msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_TerrainRaiseLimit, terrain_raise_limit);
00284 msg->getF32Fast(_PREHASH_RegionInfo, _PREHASH_TerrainLowerLimit, terrain_lower_limit);
00285 msg->getS32Fast(_PREHASH_RegionInfo, _PREHASH_PricePerMeter, price_per_meter);
00286 msg->getS32Fast(_PREHASH_RegionInfo, _PREHASH_RedirectGridX, redirect_grid_x);
00287 msg->getS32Fast(_PREHASH_RegionInfo, _PREHASH_RedirectGridY, redirect_grid_y);
00288
00289
00290 LLViewerRegion *regionp = gAgent.getRegion();
00291 if (regionp)
00292 {
00293 regionp->setRegionNameAndZone(sim_name);
00294 regionp->setRegionFlags(region_flags);
00295 regionp->setSimAccess(sim_access);
00296 regionp->setWaterHeight(water_height);
00297 regionp->setBillableFactor(billable_factor);
00298 }
00299
00300
00301 if (sGodTools
00302 && sGodTools->mPanelRegionTools
00303 && sGodTools->mPanelObjectTools
00304 && msg
00305 && gAgent.isGodlike())
00306 {
00307 LLPanelRegionTools* rtool = sGodTools->mPanelRegionTools;
00308 sGodTools->mCurrentHost = host;
00309
00310
00311 rtool->setSimName(sim_name);
00312 rtool->setEstateID(estate_id);
00313 rtool->setParentEstateID(parent_estate_id);
00314 rtool->setCheckFlags(region_flags);
00315 rtool->setBillableFactor(billable_factor);
00316 rtool->setPricePerMeter(price_per_meter);
00317 rtool->setRedirectGridX(redirect_grid_x);
00318 rtool->setRedirectGridY(redirect_grid_y);
00319 rtool->enableAllWidgets();
00320
00321 LLPanelObjectTools *otool = sGodTools->mPanelObjectTools;
00322 otool->setCheckFlags(region_flags);
00323 otool->enableAllWidgets();
00324
00325 LLViewerRegion *regionp = gAgent.getRegion();
00326 if ( !regionp )
00327 {
00328
00329 rtool->setGridPosX(-1);
00330 rtool->setGridPosY(-1);
00331 }
00332 else
00333 {
00334
00335 LLVector3d global_pos = regionp->getPosGlobalFromRegion(LLVector3::zero);
00336 S32 grid_pos_x = (S32) (global_pos.mdV[VX] / 256.0f);
00337 S32 grid_pos_y = (S32) (global_pos.mdV[VY] / 256.0f);
00338
00339 rtool->setGridPosX(grid_pos_x);
00340 rtool->setGridPosY(grid_pos_y);
00341 }
00342 }
00343 }
00344
00345
00346 void LLFloaterGodTools::sendRegionInfoRequest()
00347 {
00348 if (mPanelRegionTools) mPanelRegionTools->clearAllWidgets();
00349 if (mPanelObjectTools) mPanelObjectTools->clearAllWidgets();
00350 mCurrentHost = LLHost::invalid;
00351 mUpdateTimer.reset();
00352
00353 LLMessageSystem* msg = gMessageSystem;
00354 msg->newMessage("RequestRegionInfo");
00355 msg->nextBlock("AgentData");
00356 msg->addUUID("AgentID", gAgent.getID());
00357 msg->addUUID("SessionID", gAgent.getSessionID());
00358 gAgent.sendReliableMessage();
00359 }
00360
00361
00362 void LLFloaterGodTools::sendGodUpdateRegionInfo()
00363 {
00364 LLViewerRegion *regionp = gAgent.getRegion();
00365 if (gAgent.isGodlike()
00366 && sGodTools->mPanelRegionTools
00367 && regionp
00368 && gAgent.getRegionHost() == mCurrentHost)
00369 {
00370 LLMessageSystem *msg = gMessageSystem;
00371 LLPanelRegionTools *rtool = sGodTools->mPanelRegionTools;
00372
00373 msg->newMessage("GodUpdateRegionInfo");
00374 msg->nextBlockFast(_PREHASH_AgentData);
00375 msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
00376 msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
00377 msg->nextBlockFast(_PREHASH_RegionInfo);
00378 msg->addStringFast(_PREHASH_SimName, rtool->getSimName().c_str());
00379 msg->addU32Fast(_PREHASH_EstateID, rtool->getEstateID());
00380 msg->addU32Fast(_PREHASH_ParentEstateID, rtool->getParentEstateID());
00381 msg->addU32Fast(_PREHASH_RegionFlags, computeRegionFlags());
00382 msg->addF32Fast(_PREHASH_BillableFactor, rtool->getBillableFactor());
00383 msg->addS32Fast(_PREHASH_PricePerMeter, rtool->getPricePerMeter());
00384 msg->addS32Fast(_PREHASH_RedirectGridX, rtool->getRedirectGridX());
00385 msg->addS32Fast(_PREHASH_RedirectGridY, rtool->getRedirectGridY());
00386
00387 gAgent.sendReliableMessage();
00388 }
00389 }
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418 const F32 BILLABLE_FACTOR_DEFAULT = 1;
00419 const F32 BILLABLE_FACTOR_MIN = 0.0f;
00420 const F32 BILLABLE_FACTOR_MAX = 4.f;
00421
00422
00423 const F32 PRICE_PER_METER_DEFAULT = 1.f;
00424 const F32 PRICE_PER_METER_MIN = 0.f;
00425 const F32 PRICE_PER_METER_MAX = 100.f;
00426
00427
00428 LLPanelRegionTools::LLPanelRegionTools(const std::string& title)
00429 : LLPanel(title)
00430 {
00431 }
00432
00433 BOOL LLPanelRegionTools::postBuild()
00434 {
00435 childSetCommitCallback("region name", onChangeAnything, this);
00436 childSetKeystrokeCallback("region name", onChangeSimName, this);
00437 childSetPrevalidate("region name", &LLLineEditor::prevalidatePrintableNotPipe);
00438
00439 childSetCommitCallback("check prelude", onChangePrelude, this);
00440 childSetCommitCallback("check fixed sun", onChangeAnything, this);
00441 childSetCommitCallback("check reset home", onChangeAnything, this);
00442 childSetCommitCallback("check visible", onChangeAnything, this);
00443 childSetCommitCallback("check damage", onChangeAnything, this);
00444 childSetCommitCallback("block dwell", onChangeAnything, this);
00445 childSetCommitCallback("block terraform", onChangeAnything, this);
00446 childSetCommitCallback("allow transfer", onChangeAnything, this);
00447 childSetCommitCallback("is sandbox", onChangeAnything, this);
00448
00449 childSetAction("Bake Terrain", onBakeTerrain, this);
00450 childSetAction("Revert Terrain", onRevertTerrain, this);
00451 childSetAction("Swap Terrain", onSwapTerrain, this);
00452
00453 childSetCommitCallback("estate", onChangeAnything, this);
00454 childSetPrevalidate("estate", &LLLineEditor::prevalidatePositiveS32);
00455
00456 childSetCommitCallback("parentestate", onChangeAnything, this);
00457 childSetPrevalidate("parentestate", &LLLineEditor::prevalidatePositiveS32);
00458 childDisable("parentestate");
00459
00460 childSetCommitCallback("gridposx", onChangeAnything, this);
00461 childSetPrevalidate("gridposx", &LLLineEditor::prevalidatePositiveS32);
00462 childDisable("gridposx");
00463
00464 childSetCommitCallback("gridposy", onChangeAnything, this);
00465 childSetPrevalidate("gridposy", &LLLineEditor::prevalidatePositiveS32);
00466 childDisable("gridposy");
00467
00468 childSetCommitCallback("redirectx", onChangeAnything, this);
00469 childSetPrevalidate("redirectx", &LLLineEditor::prevalidatePositiveS32);
00470
00471 childSetCommitCallback("redirecty", onChangeAnything, this);
00472 childSetPrevalidate("redirecty", &LLLineEditor::prevalidatePositiveS32);
00473
00474 childSetCommitCallback("billable factor", onChangeAnything, this);
00475
00476 childSetCommitCallback("land cost", onChangeAnything, this);
00477
00478 childSetAction("Refresh", onRefresh, this);
00479 childSetAction("Apply", onApplyChanges, this);
00480
00481 childSetAction("Select Region", onSelectRegion, this);
00482 childSetAction("Autosave now", onSaveState, this);
00483
00484 return TRUE;
00485 }
00486
00487
00488 LLPanelRegionTools::~LLPanelRegionTools()
00489 {
00490
00491 }
00492
00493 U32 LLPanelRegionTools::computeRegionFlags(U32 flags) const
00494 {
00495 flags &= getRegionFlagsMask();
00496 flags |= getRegionFlags();
00497 return flags;
00498 }
00499
00500
00501 void LLPanelRegionTools::refresh()
00502 {
00503 }
00504
00505
00506 void LLPanelRegionTools::clearAllWidgets()
00507 {
00508
00509 childSetValue("region name", "unknown");
00510 childSetFocus("region name", FALSE);
00511
00512 childSetValue("check prelude", FALSE);
00513 childDisable("check prelude");
00514
00515 childSetValue("check fixed sun", FALSE);
00516 childDisable("check fixed sun");
00517
00518 childSetValue("check reset home", FALSE);
00519 childDisable("check reset home");
00520
00521 childSetValue("check damage", FALSE);
00522 childDisable("check damage");
00523
00524 childSetValue("check visible", FALSE);
00525 childDisable("check visible");
00526
00527 childSetValue("block terraform", FALSE);
00528 childDisable("block terraform");
00529
00530 childSetValue("block dwell", FALSE);
00531 childDisable("block dwell");
00532
00533 childSetValue("is sandbox", FALSE);
00534 childDisable("is sandbox");
00535
00536 childSetValue("billable factor", BILLABLE_FACTOR_DEFAULT);
00537 childDisable("billable factor");
00538
00539 childSetValue("land cost", PRICE_PER_METER_DEFAULT);
00540 childDisable("land cost");
00541
00542 childDisable("Apply");
00543 childDisable("Bake Terrain");
00544 childDisable("Autosave now");
00545 }
00546
00547
00548 void LLPanelRegionTools::enableAllWidgets()
00549 {
00550
00551
00552 childEnable("check prelude");
00553 childEnable("check fixed sun");
00554 childEnable("check reset home");
00555 childEnable("check damage");
00556 childDisable("check visible");
00557 childEnable("block terraform");
00558 childEnable("block dwell");
00559 childEnable("is sandbox");
00560
00561 childEnable("billable factor");
00562 childEnable("land cost");
00563
00564 childDisable("Apply");
00565 childEnable("Bake Terrain");
00566 childEnable("Autosave now");
00567 }
00568
00569
00570
00571 void LLPanelRegionTools::onSaveState(void* userdata)
00572 {
00573 if (gAgent.isGodlike())
00574 {
00575
00576 gMessageSystem->newMessageFast(_PREHASH_StateSave);
00577 gMessageSystem->nextBlockFast(_PREHASH_AgentData);
00578 gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
00579 gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
00580 gMessageSystem->nextBlockFast(_PREHASH_DataBlock);
00581 gMessageSystem->addStringFast(_PREHASH_Filename, NULL);
00582 gAgent.sendReliableMessage();
00583 }
00584 }
00585
00586 const std::string LLPanelRegionTools::getSimName() const
00587 {
00588 return childGetValue("region name");
00589 }
00590
00591 U32 LLPanelRegionTools::getEstateID() const
00592 {
00593 U32 id = (U32)childGetValue("estate").asInteger();
00594 return id;
00595 }
00596
00597 U32 LLPanelRegionTools::getParentEstateID() const
00598 {
00599 U32 id = (U32)childGetValue("parentestate").asInteger();
00600 return id;
00601 }
00602
00603 S32 LLPanelRegionTools::getRedirectGridX() const
00604 {
00605 return childGetValue("redirectx").asInteger();
00606 }
00607
00608 S32 LLPanelRegionTools::getRedirectGridY() const
00609 {
00610 return childGetValue("redirecty").asInteger();
00611 }
00612
00613 S32 LLPanelRegionTools::getGridPosX() const
00614 {
00615 return childGetValue("gridposx").asInteger();
00616 }
00617
00618 S32 LLPanelRegionTools::getGridPosY() const
00619 {
00620 return childGetValue("gridposy").asInteger();
00621 }
00622
00623 U32 LLPanelRegionTools::getRegionFlags() const
00624 {
00625 U32 flags = 0x0;
00626 flags = childGetValue("check prelude").asBoolean()
00627 ? set_prelude_flags(flags)
00628 : unset_prelude_flags(flags);
00629
00630
00631 if (childGetValue("check fixed sun").asBoolean())
00632 {
00633 flags |= REGION_FLAGS_SUN_FIXED;
00634 }
00635 if (childGetValue("check reset home").asBoolean())
00636 {
00637 flags |= REGION_FLAGS_RESET_HOME_ON_TELEPORT;
00638 }
00639 if (childGetValue("check visible").asBoolean())
00640 {
00641 flags |= REGION_FLAGS_EXTERNALLY_VISIBLE;
00642 }
00643 if (childGetValue("check damage").asBoolean())
00644 {
00645 flags |= REGION_FLAGS_ALLOW_DAMAGE;
00646 }
00647 if (childGetValue("block terraform").asBoolean())
00648 {
00649 flags |= REGION_FLAGS_BLOCK_TERRAFORM;
00650 }
00651 if (childGetValue("block dwell").asBoolean())
00652 {
00653 flags |= REGION_FLAGS_BLOCK_DWELL;
00654 }
00655 if (childGetValue("is sandbox").asBoolean())
00656 {
00657 flags |= REGION_FLAGS_SANDBOX;
00658 }
00659 return flags;
00660 }
00661
00662 U32 LLPanelRegionTools::getRegionFlagsMask() const
00663 {
00664 U32 flags = 0xffffffff;
00665 flags = childGetValue("check prelude").asBoolean()
00666 ? set_prelude_flags(flags)
00667 : unset_prelude_flags(flags);
00668
00669 if (!childGetValue("check fixed sun").asBoolean())
00670 {
00671 flags &= ~REGION_FLAGS_SUN_FIXED;
00672 }
00673 if (!childGetValue("check reset home").asBoolean())
00674 {
00675 flags &= ~REGION_FLAGS_RESET_HOME_ON_TELEPORT;
00676 }
00677 if (!childGetValue("check visible").asBoolean())
00678 {
00679 flags &= ~REGION_FLAGS_EXTERNALLY_VISIBLE;
00680 }
00681 if (!childGetValue("check damage").asBoolean())
00682 {
00683 flags &= ~REGION_FLAGS_ALLOW_DAMAGE;
00684 }
00685 if (!childGetValue("block terraform").asBoolean())
00686 {
00687 flags &= ~REGION_FLAGS_BLOCK_TERRAFORM;
00688 }
00689 if (!childGetValue("block dwell").asBoolean())
00690 {
00691 flags &= ~REGION_FLAGS_BLOCK_DWELL;
00692 }
00693 if (!childGetValue("is sandbox").asBoolean())
00694 {
00695 flags &= ~REGION_FLAGS_SANDBOX;
00696 }
00697 return flags;
00698 }
00699
00700 F32 LLPanelRegionTools::getBillableFactor() const
00701 {
00702 return (F32)childGetValue("billable factor").asReal();
00703 }
00704
00705 S32 LLPanelRegionTools::getPricePerMeter() const
00706 {
00707 return childGetValue("land cost");
00708 }
00709
00710 void LLPanelRegionTools::setSimName(char *name)
00711 {
00712 childSetValue("region name", name);
00713 }
00714
00715 void LLPanelRegionTools::setEstateID(U32 id)
00716 {
00717 childSetValue("estate", (S32)id);
00718 }
00719
00720 void LLPanelRegionTools::setGridPosX(S32 pos)
00721 {
00722 childSetValue("gridposx", pos);
00723 }
00724
00725 void LLPanelRegionTools::setGridPosY(S32 pos)
00726 {
00727 childSetValue("gridposy", pos);
00728 }
00729
00730 void LLPanelRegionTools::setRedirectGridX(S32 pos)
00731 {
00732 childSetValue("redirectx", pos);
00733 }
00734
00735 void LLPanelRegionTools::setRedirectGridY(S32 pos)
00736 {
00737 childSetValue("redirecty", pos);
00738 }
00739
00740 void LLPanelRegionTools::setParentEstateID(U32 id)
00741 {
00742 childSetValue("parentestate", (S32)id);
00743 }
00744
00745 void LLPanelRegionTools::setCheckFlags(U32 flags)
00746 {
00747 childSetValue("check prelude", is_prelude(flags) ? TRUE : FALSE);
00748 childSetValue("check fixed sun", flags & REGION_FLAGS_SUN_FIXED ? TRUE : FALSE);
00749 childSetValue("check reset home", flags & REGION_FLAGS_RESET_HOME_ON_TELEPORT ? TRUE : FALSE);
00750 childSetValue("check damage", flags & REGION_FLAGS_ALLOW_DAMAGE ? TRUE : FALSE);
00751 childSetValue("check visible", flags & REGION_FLAGS_EXTERNALLY_VISIBLE ? TRUE : FALSE);
00752 childSetValue("block terraform", flags & REGION_FLAGS_BLOCK_TERRAFORM ? TRUE : FALSE);
00753 childSetValue("block dwell", flags & REGION_FLAGS_BLOCK_DWELL ? TRUE : FALSE);
00754 childSetValue("is sandbox", flags & REGION_FLAGS_SANDBOX ? TRUE : FALSE );
00755 }
00756
00757 void LLPanelRegionTools::setBillableFactor(F32 billable_factor)
00758 {
00759 childSetValue("billable factor", billable_factor);
00760 }
00761
00762 void LLPanelRegionTools::setPricePerMeter(S32 price)
00763 {
00764 childSetValue("land cost", price);
00765 }
00766
00767
00768 void LLPanelRegionTools::onChangeAnything(LLUICtrl* ctrl, void* userdata)
00769 {
00770 if (sGodTools
00771 && userdata
00772 && gAgent.isGodlike())
00773 {
00774 LLPanelRegionTools* region_tools = (LLPanelRegionTools*) userdata;
00775 region_tools->childEnable("Apply");
00776 }
00777 }
00778
00779
00780 void LLPanelRegionTools::onChangePrelude(LLUICtrl* ctrl, void* data)
00781 {
00782
00783 LLPanelRegionTools* self = (LLPanelRegionTools*)data;
00784 if (self->childGetValue("check prelude").asBoolean())
00785 {
00786 self->childSetValue("check fixed sun", TRUE);
00787 self->childSetValue("check reset home", TRUE);
00788 }
00789
00790 onChangeAnything(ctrl, data);
00791 }
00792
00793
00794 void LLPanelRegionTools::onChangeSimName(LLLineEditor* caller, void* userdata )
00795 {
00796 if (sGodTools
00797 && userdata
00798 && gAgent.isGodlike())
00799 {
00800 LLPanelRegionTools* region_tools = (LLPanelRegionTools*) userdata;
00801 region_tools->childEnable("Apply");
00802 }
00803 }
00804
00805
00806 void LLPanelRegionTools::onRefresh(void* userdata)
00807 {
00808 LLViewerRegion *region = gAgent.getRegion();
00809 if (region
00810 && sGodTools
00811 && gAgent.isGodlike())
00812 {
00813 sGodTools->sendRegionInfoRequest();
00814 }
00815 }
00816
00817
00818 void LLPanelRegionTools::onApplyChanges(void* userdata)
00819 {
00820 LLViewerRegion *region = gAgent.getRegion();
00821 if (region
00822 && sGodTools
00823 && userdata
00824 && gAgent.isGodlike())
00825 {
00826 LLPanelRegionTools* region_tools = (LLPanelRegionTools*) userdata;
00827
00828 region_tools->childDisable("Apply");
00829 sGodTools->sendGodUpdateRegionInfo();
00830 }
00831 }
00832
00833
00834 void LLPanelRegionTools::onBakeTerrain(void *userdata)
00835 {
00836 LLPanelRequestTools::sendRequest("terrain", "bake", gAgent.getRegionHost());
00837 }
00838
00839
00840 void LLPanelRegionTools::onRevertTerrain(void *userdata)
00841 {
00842 LLPanelRequestTools::sendRequest("terrain", "revert", gAgent.getRegionHost());
00843 }
00844
00845
00846 void LLPanelRegionTools::onSwapTerrain(void *userdata)
00847 {
00848 LLPanelRequestTools::sendRequest("terrain", "swap", gAgent.getRegionHost());
00849 }
00850
00851
00852 void LLPanelRegionTools::onSelectRegion(void* userdata)
00853 {
00854 llinfos << "LLPanelRegionTools::onSelectRegion" << llendl;
00855
00856 LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(gAgent.getPositionGlobal());
00857 if (!regionp)
00858 {
00859 return;
00860 }
00861
00862 LLVector3d north_east(REGION_WIDTH_METERS, REGION_WIDTH_METERS, 0);
00863 LLViewerParcelMgr::getInstance()->selectLand(regionp->getOriginGlobal(),
00864 regionp->getOriginGlobal() + north_east, FALSE);
00865
00866 }
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891 const F32 HOURS_TO_RADIANS = (2.f*F_PI)/24.f;
00892 const char FLOATER_GRID_ADMIN_TITLE[] = "Grid Administration";
00893
00894
00895 LLPanelGridTools::LLPanelGridTools(const std::string& name) :
00896 LLPanel(name)
00897 {
00898 }
00899
00900
00901 LLPanelGridTools::~LLPanelGridTools()
00902 {
00903 }
00904
00905 BOOL LLPanelGridTools::postBuild()
00906 {
00907 childSetAction("Kick all users", onClickKickAll, this);
00908 childSetAction("Flush This Region's Map Visibility Caches", onClickFlushMapVisibilityCaches, this);
00909
00910 return TRUE;
00911 }
00912
00913 void LLPanelGridTools::refresh()
00914 {
00915 }
00916
00917
00918
00919 void LLPanelGridTools::onClickKickAll(void* userdata)
00920 {
00921 LLPanelGridTools* self = (LLPanelGridTools*) userdata;
00922
00923 S32 left, top;
00924 gFloaterView->getNewFloaterPosition(&left, &top);
00925 LLRect rect(left, top, left+400, top-300);
00926
00927 gViewerWindow->alertXmlEditText("KickAllUsers", LLString::format_map_t(),
00928 NULL, NULL,
00929 LLPanelGridTools::confirmKick, self);
00930 }
00931
00932
00933 void LLPanelGridTools::confirmKick(S32 option, const LLString& text, void* userdata)
00934 {
00935 LLPanelGridTools* self = (LLPanelGridTools*) userdata;
00936
00937 if (option == 0)
00938 {
00939 self->mKickMessage = text;
00940 gViewerWindow->alertXml("ConfirmKick",LLPanelGridTools::finishKick, self);
00941 }
00942 }
00943
00944
00945
00946 void LLPanelGridTools::finishKick(S32 option, void* userdata)
00947 {
00948 LLPanelGridTools* self = (LLPanelGridTools*) userdata;
00949
00950 if (option == 0)
00951 {
00952 LLMessageSystem* msg = gMessageSystem;
00953
00954 msg->newMessageFast(_PREHASH_GodKickUser);
00955 msg->nextBlockFast(_PREHASH_UserInfo);
00956 msg->addUUIDFast(_PREHASH_GodID, gAgent.getID());
00957 msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
00958 msg->addUUIDFast(_PREHASH_AgentID, LL_UUID_ALL_AGENTS );
00959 msg->addU32("KickFlags", KICK_FLAGS_DEFAULT );
00960 msg->addStringFast(_PREHASH_Reason, self->mKickMessage.c_str() );
00961 gAgent.sendReliableMessage();
00962 }
00963 }
00964
00965
00966
00967 void LLPanelGridTools::onClickFlushMapVisibilityCaches(void* data)
00968 {
00969 gViewerWindow->alertXml("FlushMapVisibilityCaches",
00970 flushMapVisibilityCachesConfirm, data);
00971 }
00972
00973
00974 void LLPanelGridTools::flushMapVisibilityCachesConfirm(S32 option, void* data)
00975 {
00976 if (option != 0) return;
00977
00978 LLPanelGridTools* self = (LLPanelGridTools*)data;
00979 if (!self) return;
00980
00981
00982
00983 LLMessageSystem* msg = gMessageSystem;
00984 msg->newMessage("EstateOwnerMessage");
00985 msg->nextBlockFast(_PREHASH_AgentData);
00986 msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
00987 msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
00988 msg->addUUIDFast(_PREHASH_TransactionID, LLUUID::null);
00989 msg->nextBlock("MethodData");
00990 msg->addString("Method", "refreshmapvisibility");
00991 msg->addUUID("Invoice", LLUUID::null);
00992 msg->nextBlock("ParamList");
00993 msg->addString("Parameter", gAgent.getID().asString());
00994 gAgent.sendReliableMessage();
00995 }
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023 LLPanelObjectTools::LLPanelObjectTools(const std::string& title)
01024 : LLPanel(title), mTargetAvatar()
01025 {
01026 }
01027
01028
01029 LLPanelObjectTools::~LLPanelObjectTools()
01030 {
01031
01032 }
01033
01034 BOOL LLPanelObjectTools::postBuild()
01035 {
01036 childSetCommitCallback("disable scripts", onChangeAnything, this);
01037 childSetCommitCallback("disable collisions", onChangeAnything, this);
01038 childSetCommitCallback("disable physics", onChangeAnything, this);
01039
01040 childSetAction("Apply", onApplyChanges, this);
01041
01042 childSetAction("Set Target", onClickSet, this);
01043
01044 childSetAction("Delete Target's Scripted Objects On Others Land", onClickDeletePublicOwnedBy, this);
01045 childSetAction("Delete Target's Scripted Objects On *Any* Land", onClickDeleteAllScriptedOwnedBy, this);
01046 childSetAction("Delete *ALL* Of Target's Objects", onClickDeleteAllOwnedBy, this);
01047
01048 childSetAction("Get Top Colliders", onGetTopColliders, this);
01049 childSetAction("Get Top Scripts", onGetTopScripts, this);
01050 childSetAction("Scripts digest", onGetScriptDigest, this);
01051
01052 return TRUE;
01053 }
01054
01055 void LLPanelObjectTools::setTargetAvatar(const LLUUID &target_id)
01056 {
01057 mTargetAvatar = target_id;
01058 if (target_id.isNull())
01059 {
01060 childSetValue("target_avatar_name", "(no target)");
01061 }
01062 }
01063
01064
01065 void LLPanelObjectTools::refresh()
01066 {
01067 LLViewerRegion *regionp = gAgent.getRegion();
01068 if (regionp)
01069 {
01070 childSetText("region name", regionp->getName());
01071 }
01072 }
01073
01074
01075 U32 LLPanelObjectTools::computeRegionFlags(U32 flags) const
01076 {
01077 if (childGetValue("disable scripts").asBoolean())
01078 {
01079 flags |= REGION_FLAGS_SKIP_SCRIPTS;
01080 }
01081 else
01082 {
01083 flags &= ~REGION_FLAGS_SKIP_SCRIPTS;
01084 }
01085 if (childGetValue("disable collisions").asBoolean())
01086 {
01087 flags |= REGION_FLAGS_SKIP_COLLISIONS;
01088 }
01089 else
01090 {
01091 flags &= ~REGION_FLAGS_SKIP_COLLISIONS;
01092 }
01093 if (childGetValue("disable physics").asBoolean())
01094 {
01095 flags |= REGION_FLAGS_SKIP_PHYSICS;
01096 }
01097 else
01098 {
01099 flags &= ~REGION_FLAGS_SKIP_PHYSICS;
01100 }
01101 return flags;
01102 }
01103
01104
01105 void LLPanelObjectTools::setCheckFlags(U32 flags)
01106 {
01107 childSetValue("disable scripts", flags & REGION_FLAGS_SKIP_SCRIPTS ? TRUE : FALSE);
01108 childSetValue("disable collisions", flags & REGION_FLAGS_SKIP_COLLISIONS ? TRUE : FALSE);
01109 childSetValue("disable physics", flags & REGION_FLAGS_SKIP_PHYSICS ? TRUE : FALSE);
01110 }
01111
01112
01113 void LLPanelObjectTools::clearAllWidgets()
01114 {
01115 childSetValue("disable scripts", FALSE);
01116 childDisable("disable scripts");
01117
01118 childDisable("Apply");
01119 childDisable("Set Target");
01120 childDisable("Delete Target's Scripted Objects On Others Land");
01121 childDisable("Delete Target's Scripted Objects On *Any* Land");
01122 childDisable("Delete *ALL* Of Target's Objects");
01123 }
01124
01125
01126 void LLPanelObjectTools::enableAllWidgets()
01127 {
01128 childEnable("disable scripts");
01129
01130 childDisable("Apply");
01131 childEnable("Set Target");
01132 childEnable("Delete Target's Scripted Objects On Others Land");
01133 childEnable("Delete Target's Scripted Objects On *Any* Land");
01134 childEnable("Delete *ALL* Of Target's Objects");
01135 childEnable("Get Top Colliders");
01136 childEnable("Get Top Scripts");
01137 }
01138
01139
01140
01141 void LLPanelObjectTools::onGetTopColliders(void* userdata)
01142 {
01143 if (sGodTools
01144 && gAgent.isGodlike())
01145 {
01146 LLFloaterTopObjects::show();
01147 LLFloaterTopObjects::setMode(STAT_REPORT_TOP_COLLIDERS);
01148 LLFloaterTopObjects::onRefresh(NULL);
01149 }
01150 }
01151
01152
01153 void LLPanelObjectTools::onGetTopScripts(void* userdata)
01154 {
01155 if (sGodTools
01156 && gAgent.isGodlike())
01157 {
01158 LLFloaterTopObjects::show();
01159 LLFloaterTopObjects::setMode(STAT_REPORT_TOP_SCRIPTS);
01160 LLFloaterTopObjects::onRefresh(NULL);
01161 }
01162 }
01163
01164
01165 void LLPanelObjectTools::onGetScriptDigest(void* userdata)
01166 {
01167 if (sGodTools
01168 && gAgent.isGodlike())
01169 {
01170
01171
01172 LLPanelRequestTools::sendRequest("scriptdigest","0",gAgent.getRegionHost());
01173 }
01174 }
01175
01176 void LLPanelObjectTools::onClickDeletePublicOwnedBy(void* userdata)
01177 {
01178
01179 LLPanelObjectTools* panelp = (LLPanelObjectTools*)userdata;
01180 if (!panelp->mTargetAvatar.isNull())
01181 {
01182 panelp->mSimWideDeletesFlags =
01183 SWD_SCRIPTED_ONLY | SWD_OTHERS_LAND_ONLY;
01184
01185 LLStringBase<char>::format_map_t args;
01186 args["[AVATAR_NAME]"] = panelp->childGetValue("target_avatar_name").asString();
01187
01188 gViewerWindow->alertXml( "GodDeleteAllScriptedPublicObjectsByUser",
01189 args,
01190 callbackSimWideDeletes,
01191 userdata);
01192 }
01193 }
01194
01195
01196 void LLPanelObjectTools::onClickDeleteAllScriptedOwnedBy(void* userdata)
01197 {
01198
01199 LLPanelObjectTools* panelp = (LLPanelObjectTools*)userdata;
01200 if (!panelp->mTargetAvatar.isNull())
01201 {
01202 panelp->mSimWideDeletesFlags = SWD_SCRIPTED_ONLY;
01203
01204 LLStringBase<char>::format_map_t args;
01205 args["[AVATAR_NAME]"] = panelp->childGetValue("target_avatar_name").asString();
01206
01207 gViewerWindow->alertXml( "GodDeleteAllScriptedObjectsByUser",
01208 args,
01209 callbackSimWideDeletes,
01210 userdata);
01211 }
01212 }
01213
01214
01215 void LLPanelObjectTools::onClickDeleteAllOwnedBy(void* userdata)
01216 {
01217
01218 LLPanelObjectTools* panelp = (LLPanelObjectTools*)userdata;
01219 if (!panelp->mTargetAvatar.isNull())
01220 {
01221 panelp->mSimWideDeletesFlags = 0;
01222
01223 LLStringBase<char>::format_map_t args;
01224 args["[AVATAR_NAME]"] = panelp->childGetValue("target_avatar_name").asString();
01225
01226 gViewerWindow->alertXml( "GodDeleteAllObjectsByUser",
01227 args,
01228 callbackSimWideDeletes,
01229 userdata);
01230 }
01231 }
01232
01233
01234 void LLPanelObjectTools::callbackSimWideDeletes( S32 option, void* userdata )
01235 {
01236 if (option == 0)
01237 {
01238 LLPanelObjectTools* object_tools = (LLPanelObjectTools*) userdata;
01239 if (!object_tools->mTargetAvatar.isNull())
01240 {
01241 send_sim_wide_deletes(object_tools->mTargetAvatar,
01242 object_tools->mSimWideDeletesFlags);
01243 }
01244 }
01245 }
01246
01247 void LLPanelObjectTools::onClickSet(void* data)
01248 {
01249 LLPanelObjectTools* panelp = (LLPanelObjectTools*) data;
01250
01251 gFloaterView->getParentFloater(panelp)->addDependentFloater(LLFloaterAvatarPicker::show(callbackAvatarID, data));
01252 }
01253
01254 void LLPanelObjectTools::onClickSetBySelection(void* data)
01255 {
01256 LLPanelObjectTools* panelp = (LLPanelObjectTools*) data;
01257 if (!panelp) return;
01258
01259 const BOOL non_root_ok = TRUE;
01260 LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode(NULL, non_root_ok);
01261 if (!node) return;
01262
01263 LLString owner_name;
01264 LLUUID owner_id;
01265 LLSelectMgr::getInstance()->selectGetOwner(owner_id, owner_name);
01266
01267 panelp->mTargetAvatar = owner_id;
01268 LLString name = "Object " + node->mName + " owned by " + owner_name;
01269 panelp->childSetValue("target_avatar_name", name);
01270 }
01271
01272
01273 void LLPanelObjectTools::callbackAvatarID(const std::vector<std::string>& names, const std::vector<LLUUID>& ids, void* data)
01274 {
01275 LLPanelObjectTools* object_tools = (LLPanelObjectTools*) data;
01276 if (ids.empty() || names.empty()) return;
01277 object_tools->mTargetAvatar = ids[0];
01278 object_tools->childSetValue("target_avatar_name", names[0]);
01279 object_tools->refresh();
01280 }
01281
01282
01283
01284 void LLPanelObjectTools::onChangeAnything(LLUICtrl* ctrl, void* userdata)
01285 {
01286 if (sGodTools
01287 && userdata
01288 && gAgent.isGodlike())
01289 {
01290 LLPanelObjectTools* object_tools = (LLPanelObjectTools*) userdata;
01291 object_tools->childEnable("Apply");
01292 }
01293 }
01294
01295
01296 void LLPanelObjectTools::onApplyChanges(void* userdata)
01297 {
01298 LLViewerRegion *region = gAgent.getRegion();
01299 if (region
01300 && sGodTools
01301 && userdata
01302 && gAgent.isGodlike())
01303 {
01304 LLPanelObjectTools* object_tools = (LLPanelObjectTools*) userdata;
01305
01306
01307 object_tools->childDisable("Apply");
01308 sGodTools->sendGodUpdateRegionInfo();
01309 }
01310 }
01311
01312
01313
01314
01315
01316
01317 const char SELECTION[] = "Selection";
01318 const char AGENT_REGION[] = "Agent Region";
01319
01320 LLPanelRequestTools::LLPanelRequestTools(const std::string& name):
01321 LLPanel(name)
01322 {
01323 }
01324
01325 LLPanelRequestTools::~LLPanelRequestTools()
01326 {
01327 }
01328
01329 BOOL LLPanelRequestTools::postBuild()
01330 {
01331 childSetAction("Make Request", onClickRequest, this);
01332
01333 refresh();
01334
01335 return TRUE;
01336 }
01337
01338 void LLPanelRequestTools::refresh()
01339 {
01340 std::string buffer = childGetValue("destination");
01341 LLCtrlListInterface *list = childGetListInterface("destination");
01342 if (!list) return;
01343
01344 list->operateOnAll(LLCtrlListInterface::OP_DELETE);
01345 list->addSimpleElement(SELECTION);
01346 list->addSimpleElement(AGENT_REGION);
01347 for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->mActiveRegionList.begin();
01348 iter != LLWorld::getInstance()->mActiveRegionList.end(); ++iter)
01349 {
01350 LLViewerRegion* regionp = *iter;
01351 LLString name = regionp->getName();
01352 if (!name.empty())
01353 {
01354 list->addSimpleElement(name);
01355 }
01356 }
01357 if(!buffer.empty())
01358 {
01359 list->selectByValue(buffer);
01360 }
01361 else
01362 {
01363 list->selectByValue(SELECTION);
01364 }
01365 }
01366
01367
01368
01369 void LLPanelRequestTools::sendRequest(const char *request,
01370 const char *parameter,
01371 const LLHost& host)
01372 {
01373 llinfos << "Sending request '" << request << "', '"
01374 << parameter << "' to " << host << llendl;
01375 LLMessageSystem* msg = gMessageSystem;
01376 msg->newMessage("GodlikeMessage");
01377 msg->nextBlockFast(_PREHASH_AgentData);
01378 msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
01379 msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
01380 msg->addUUIDFast(_PREHASH_TransactionID, LLUUID::null);
01381 msg->nextBlock("MethodData");
01382 msg->addString("Method", request);
01383 msg->addUUID("Invoice", LLUUID::null);
01384 msg->nextBlock("ParamList");
01385 msg->addString("Parameter", parameter);
01386 msg->sendReliable(host);
01387 }
01388
01389
01390 void LLPanelRequestTools::onClickRequest(void* data)
01391 {
01392 LLPanelRequestTools* self = (LLPanelRequestTools*)data;
01393 const std::string dest = self->childGetValue("destination").asString();
01394 if(dest == SELECTION)
01395 {
01396 std::string req = self->childGetValue("request");
01397 req = req.substr(0, req.find_first_of(" "));
01398 std::string param = self->childGetValue("parameter");
01399 LLSelectMgr::getInstance()->sendGodlikeRequest(req, param);
01400 }
01401 else if(dest == AGENT_REGION)
01402 {
01403 self->sendRequest(gAgent.getRegionHost());
01404 }
01405 else
01406 {
01407
01408 for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->mActiveRegionList.begin();
01409 iter != LLWorld::getInstance()->mActiveRegionList.end(); ++iter)
01410 {
01411 LLViewerRegion* regionp = *iter;
01412 if(dest == regionp->getName())
01413 {
01414
01415 self->sendRequest(regionp->getHost());
01416 }
01417 }
01418 }
01419 }
01420
01421 void terrain_download_done(void** data, S32 status, LLExtStat ext_status)
01422 {
01423 LLNotifyBox::showXml("TerrainDownloaded");
01424 }
01425
01426
01427 void test_callback(const LLTSCode status)
01428 {
01429 llinfos << "Test transfer callback returned!" << llendl;
01430 }
01431
01432
01433 void LLPanelRequestTools::sendRequest(const LLHost& host)
01434 {
01435
01436
01437 std::string req = childGetValue("request");
01438 if (req == "terrain download")
01439 {
01440 gXferManager->requestFile("terrain.raw", "terrain.raw", LL_PATH_NONE,
01441 host,
01442 FALSE,
01443 terrain_download_done,
01444 NULL);
01445 }
01446 else
01447 {
01448 req = req.substr(0, req.find_first_of(" "));
01449 sendRequest(req.c_str(), childGetValue("parameter").asString().c_str(), host);
01450 }
01451 }
01452
01453
01454 void send_sim_wide_deletes(const LLUUID& owner_id, U32 flags)
01455 {
01456 LLMessageSystem* msg = gMessageSystem;
01457 msg->newMessageFast(_PREHASH_SimWideDeletes);
01458 msg->nextBlockFast(_PREHASH_AgentData);
01459 msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
01460 msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
01461 msg->nextBlockFast(_PREHASH_DataBlock);
01462 msg->addUUIDFast(_PREHASH_TargetID, owner_id);
01463 msg->addU32Fast(_PREHASH_Flags, flags);
01464 gAgent.sendReliableMessage();
01465 }