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

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

游戏引擎

开发平台：

C++ Builder

llfloaterbuyland.cpp：源码内容
  1. /** 
  2.  * @file llfloaterbuyland.cpp
  3.  * @brief LLFloaterBuyLand class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2005-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 "llfloaterbuyland.h"
  37. // viewer includes
  38. #include "llagent.h"
  39. #include "llbutton.h"
  40. #include "llcachename.h"
  41. #include "llcheckboxctrl.h"
  42. #include "llcombobox.h"
  43. #include "llconfirmationmanager.h"
  44. #include "llcurrencyuimanager.h"
  45. #include "llfloater.h"
  46. #include "llfloaterreg.h"
  47. #include "llfloatertools.h"
  48. #include "llframetimer.h"
  49. #include "lliconctrl.h"
  50. #include "lllineeditor.h"
  51. #include "llnotificationsutil.h"
  52. #include "llparcel.h"
  53. #include "llslurl.h"
  54. #include "llstatusbar.h"
  55. #include "lltextbox.h"
  56. #include "lltexturectrl.h"
  57. #include "llviewchildren.h"
  58. #include "llviewercontrol.h"
  59. #include "lluictrlfactory.h"
  60. #include "llviewerparcelmgr.h"
  61. #include "llviewerregion.h"
  62. #include "llviewertexteditor.h"
  63. #include "llviewerwindow.h"
  64. #include "llweb.h"
  65. #include "llwindow.h"
  66. #include "llworld.h"
  67. #include "llxmlrpctransaction.h"
  68. #include "llviewernetwork.h"
  69. #include "roles_constants.h"
  71. // NOTE: This is duplicated in lldatamoney.cpp ...
  72. const F32 GROUP_LAND_BONUS_FACTOR = 1.1f;
  73. const F64 CURRENCY_ESTIMATE_FREQUENCY = 0.5;
  74. // how long of a pause in typing a currency buy amount before an
  75. // estimate is fetched from the server
  77. class LLFloaterBuyLandUI
  78. : public LLFloater
  79. {
  80. public:
  81. LLFloaterBuyLandUI(const LLSD& key);
  82. virtual ~LLFloaterBuyLandUI();
  84. /*virtual*/ void onClose(bool app_quitting);
  86. // Left padding for maturity rating icon.
  87. static const S32 ICON_PAD = 2;
  89. private:
  90. class SelectionObserver : public LLParcelObserver
  91. {
  92. public:
  93. SelectionObserver(LLFloaterBuyLandUI* floater) : mFloater(floater) {}
  94. virtual void changed();
  95. private:
  96. LLFloaterBuyLandUI* mFloater;
  97. };
  99. private:
  100. SelectionObserver mParcelSelectionObserver;
  101. LLViewerRegion* mRegion;
  102. LLParcelSelectionHandle mParcel;
  103. bool mIsClaim;
  104. bool mIsForGroup;
  106. bool mCanBuy;
  107. bool mCannotBuyIsError;
  108. std::string mCannotBuyReason;
  109. std::string mCannotBuyURI;
  111. bool mBought;
  113. // information about the agent
  114. S32 mAgentCommittedTier;
  115. S32 mAgentCashBalance;
  116. bool mAgentHasNeverOwnedLand;
  118. // information about the parcel
  119. bool mParcelValid;
  120. bool mParcelIsForSale;
  121. bool mParcelIsGroupLand;
  122. S32 mParcelGroupContribution;
  123. S32 mParcelPrice;
  124. S32 mParcelActualArea;
  125. S32 mParcelBillableArea;
  126. S32 mParcelSupportedObjects;
  127. bool mParcelSoldWithObjects;
  128. std::string mParcelLocation;
  129. LLUUID mParcelSnapshot;
  130. std::string mParcelSellerName;
  132. // user's choices
  133. S32 mUserPlanChoice;
  135. // from website
  136. bool mSiteValid;
  137. bool mSiteMembershipUpgrade;
  138. std::string mSiteMembershipAction;
  139. std::vector<std::string>
  140. mSiteMembershipPlanIDs;
  141. std::vector<std::string>
  142. mSiteMembershipPlanNames;
  143. bool mSiteLandUseUpgrade;
  144. std::string mSiteLandUseAction;
  145. std::string mSiteConfirm;
  147. // values in current Preflight transaction... used to avoid extra
  148. // preflights when the parcel manager goes update crazy
  149. S32 mPreflightAskBillableArea;
  150. S32 mPreflightAskCurrencyBuy;
  152. LLViewChildren mChildren;
  153. LLCurrencyUIManager mCurrency;
  155. enum TransactionType
  156. {
  157. TransactionPreflight,
  158. TransactionCurrency,
  159. TransactionBuy
  160. };
  161. LLXMLRPCTransaction* mTransaction;
  162. TransactionType  mTransactionType;
  164. LLViewerParcelMgr::ParcelBuyInfo* mParcelBuyInfo;
  166. public:
  167. void setForGroup(bool is_for_group);
  168. void setParcel(LLViewerRegion* region, LLParcelSelectionHandle parcel);
  170. void updateAgentInfo();
  171. void updateParcelInfo();
  172. void updateCovenantInfo();
  173. static void onChangeAgreeCovenant(LLUICtrl* ctrl, void* user_data);
  174. void updateFloaterCovenantText(const std::string& string, const LLUUID &asset_id);
  175. void updateFloaterEstateName(const std::string& name);
  176. void updateFloaterLastModified(const std::string& text);
  177. void updateFloaterEstateOwnerName(const std::string& name);
  178. void updateWebSiteInfo();
  179. void finishWebSiteInfo();
  181. void runWebSitePrep(const std::string& password);
  182. void finishWebSitePrep();
  183. void sendBuyLand();
  185. void updateNames();
  186. // Name cache callback
  187. void updateGroupName(const LLUUID& id,
  188.  const std::string& first_name,
  189.  const std::string& last_name,
  190.  BOOL is_group);
  192. void refreshUI();
  194. void startTransaction(TransactionType type, const LLXMLRPCValue& params);
  195. bool checkTransaction();
  197. void tellUserError(const std::string& message, const std::string& uri);
  199. virtual BOOL postBuild();
  201. void startBuyPreConfirm();
  202. void startBuyPostConfirm(const std::string& password);
  204. void onClickBuy();
  205. void onClickCancel();
  206.  void onClickErrorWeb();
  208. virtual void draw();
  209. virtual BOOL canClose();
  211. void onVisibilityChange ( const LLSD& new_visibility );
  213. };
  215. // static
  216. void LLFloaterBuyLand::buyLand(
  217. LLViewerRegion* region, LLParcelSelectionHandle parcel, bool is_for_group)
  218. {
  219. if(is_for_group && !gAgent.hasPowerInActiveGroup(GP_LAND_DEED))
  220. {
  221. LLNotificationsUtil::add("OnlyOfficerCanBuyLand");
  222. return;
  223. }
  225. LLFloaterBuyLandUI* ui = LLFloaterReg::showTypedInstance<LLFloaterBuyLandUI>("buy_land");
  226. if (ui)
  227. {
  228. ui->setForGroup(is_for_group);
  229. ui->setParcel(region, parcel);
  230. }
  231. }
  233. // static
  234. void LLFloaterBuyLand::updateCovenantText(const std::string& string, const LLUUID &asset_id)
  235. {
  236. LLFloaterBuyLandUI* floater = LLFloaterReg::findTypedInstance<LLFloaterBuyLandUI>("buy_land");
  237. if (floater)
  238. {
  239. floater->updateFloaterCovenantText(string, asset_id);
  240. }
  241. }
  243. // static
  244. void LLFloaterBuyLand::updateEstateName(const std::string& name)
  245. {
  246. LLFloaterBuyLandUI* floater = LLFloaterReg::findTypedInstance<LLFloaterBuyLandUI>("buy_land");
  247. if (floater)
  248. {
  249. floater->updateFloaterEstateName(name);
  250. }
  251. }
  253. // static
  254. void LLFloaterBuyLand::updateLastModified(const std::string& text)
  255. {
  256. LLFloaterBuyLandUI* floater = LLFloaterReg::findTypedInstance<LLFloaterBuyLandUI>("buy_land");
  257. if (floater)
  258. {
  259. floater->updateFloaterLastModified(text);
  260. }
  261. }
  263. // static
  264. void LLFloaterBuyLand::updateEstateOwnerName(const std::string& name)
  265. {
  266. LLFloaterBuyLandUI* floater = LLFloaterReg::findTypedInstance<LLFloaterBuyLandUI>("buy_land");
  267. if (floater)
  268. {
  269. floater->updateFloaterEstateOwnerName(name);
  270. }
  271. }
  273. // static
  274. LLFloater* LLFloaterBuyLand::buildFloater(const LLSD& key)
  275. {
  276. LLFloaterBuyLandUI* floater = new LLFloaterBuyLandUI(key);
  277. return floater;
  278. }
  280. //----------------------------------------------------------------------------
  281. // LLFloaterBuyLandUI
  282. //----------------------------------------------------------------------------
  284. #if LL_WINDOWS
  285. // passing 'this' during construction generates a warning. The callee
  286. // only uses the pointer to hold a reference to 'this' which is
  287. // already valid, so this call does the correct thing. Disable the
  288. // warning so that we can compile without generating a warning.
  289. #pragma warning(disable : 4355)
  290. #endif 
  291. LLFloaterBuyLandUI::LLFloaterBuyLandUI(const LLSD& key)
  292. : LLFloater(LLSD()),
  293. mParcelSelectionObserver(this),
  294. mParcel(0),
  295. mBought(false),
  296. mParcelValid(false), mSiteValid(false),
  297. mChildren(*this), mCurrency(*this), mTransaction(0),
  298. mParcelBuyInfo(0)
  299. {
  300. LLViewerParcelMgr::getInstance()->addObserver(&mParcelSelectionObserver);
  302. //  LLUICtrlFactory::getInstance()->buildFloater(sInstance, "floater_buy_land.xml");
  303. }
  305. LLFloaterBuyLandUI::~LLFloaterBuyLandUI()
  306. {
  307. LLViewerParcelMgr::getInstance()->removeObserver(&mParcelSelectionObserver);
  308. LLViewerParcelMgr::getInstance()->deleteParcelBuy(&mParcelBuyInfo);
  310. delete mTransaction;
  311. }
  313. // virtual
  314. void LLFloaterBuyLandUI::onClose(bool app_quitting)
  315. {
  316. // This object holds onto observer, transactions, and parcel state.
  317. // Despite being single_instance, destroy it to call destructors and clean
  318. // everything up.
  319. setVisible(FALSE);
  320. destroy();
  321. }
  323. void LLFloaterBuyLandUI::SelectionObserver::changed()
  324. {
  325. if (LLViewerParcelMgr::getInstance()->selectionEmpty())
  326. {
  327. mFloater->closeFloater();
  328. }
  329. else
  330. {
  331. mFloater->setParcel(LLViewerParcelMgr::getInstance()->getSelectionRegion(),
  332. LLViewerParcelMgr::getInstance()->getParcelSelection());
  333. }
  334. }
  337. void LLFloaterBuyLandUI::updateAgentInfo()
  338. {
  339. mAgentCommittedTier = gStatusBar->getSquareMetersCommitted();
  340. mAgentCashBalance = gStatusBar->getBalance();
  342. // *TODO: This is an approximation, we should send this value down
  343. // to the viewer. See SL-10728 for details.
  344. mAgentHasNeverOwnedLand = mAgentCommittedTier == 0;
  345. }
  347. void LLFloaterBuyLandUI::updateParcelInfo()
  348. {
  349. LLParcel* parcel = mParcel->getParcel();
  350. mParcelValid = parcel && mRegion;
  351. mParcelIsForSale = false;
  352. mParcelIsGroupLand = false;
  353. mParcelGroupContribution = 0;
  354. mParcelPrice = 0;
  355. mParcelActualArea = 0;
  356. mParcelBillableArea = 0;
  357. mParcelSupportedObjects = 0;
  358. mParcelSoldWithObjects = false;
  359. mParcelLocation = "";
  360. mParcelSnapshot.setNull();
  361. mParcelSellerName = "";
  363. mCanBuy = false;
  364. mCannotBuyIsError = false;
  366. if (!mParcelValid)
  367. {
  368. mCannotBuyReason = getString("no_land_selected");
  369. return;
  370. }
  372. if (mParcel->getMultipleOwners())
  373. {
  374. mCannotBuyReason = getString("multiple_parcels_selected");
  375. return;
  376. }
  378. const LLUUID& parcelOwner = parcel->getOwnerID();
  380. mIsClaim = parcel->isPublic();
  381. if (!mIsClaim)
  382. {
  383. mParcelActualArea = parcel->getArea();
  384. mParcelIsForSale = parcel->getForSale();
  385. mParcelIsGroupLand = parcel->getIsGroupOwned();
  386. mParcelPrice = mParcelIsForSale ? parcel->getSalePrice() : 0;
  388. if (mParcelIsGroupLand)
  389. {
  390. LLUUID group_id = parcel->getGroupID();
  391. mParcelGroupContribution = gAgent.getGroupContribution(group_id);
  392. }
  393. }
  394. else
  395. {
  396. mParcelActualArea = mParcel->getClaimableArea();
  397. mParcelIsForSale = true;
  398. mParcelPrice = mParcelActualArea * parcel->getClaimPricePerMeter();
  399. }
  401. mParcelBillableArea =
  402. llround(mRegion->getBillableFactor() * mParcelActualArea);
  404.   mParcelSupportedObjects = llround(
  405. parcel->getMaxPrimCapacity() * parcel->getParcelPrimBonus()); 
  406.   // Can't have more than region max tasks, regardless of parcel 
  407.   // object bonus factor. 
  408.   LLViewerRegion* region = LLViewerParcelMgr::getInstance()->getSelectionRegion(); 
  409.   if(region) 
  410.   { 
  411. S32 max_tasks_per_region = (S32)region->getMaxTasks(); 
  412. mParcelSupportedObjects = llmin(
  413. mParcelSupportedObjects, max_tasks_per_region); 
  414.   } 
  416. mParcelSoldWithObjects = parcel->getSellWithObjects();
  419. LLVector3 center = parcel->getCenterpoint();
  420. mParcelLocation = llformat("%s %d,%d",
  421. mRegion->getName().c_str(),
  422. (int)center[VX], (int)center[VY]
  423. );
  425. mParcelSnapshot = parcel->getSnapshotID();
  427. updateNames();
  429. bool haveEnoughCash = mParcelPrice <= mAgentCashBalance;
  430. S32 cashBuy = haveEnoughCash ? 0 : (mParcelPrice - mAgentCashBalance);
  431. mCurrency.setAmount(cashBuy, true);
  432. mCurrency.setZeroMessage(haveEnoughCash ? getString("none_needed") : LLStringUtil::null);
  434. // checks that we can buy the land
  436. if(mIsForGroup && !gAgent.hasPowerInActiveGroup(GP_LAND_DEED))
  437. {
  438. mCannotBuyReason = getString("cant_buy_for_group");
  439. return;
  440. }
  442. if (!mIsClaim)
  443. {
  444. const LLUUID& authorizedBuyer = parcel->getAuthorizedBuyerID();
  445. const LLUUID buyer = gAgent.getID();
  446. const LLUUID newOwner = mIsForGroup ? gAgent.getGroupID() : buyer;
  448. if (!mParcelIsForSale
  449. || (mParcelPrice == 0  &&  authorizedBuyer.isNull()))
  450. {
  452. mCannotBuyReason = getString("parcel_not_for_sale");
  453. return;
  454. }
  456. if (parcelOwner == newOwner)
  457. {
  458. if (mIsForGroup)
  459. {
  460. mCannotBuyReason = getString("group_already_owns");
  461. }
  462. else
  463. {
  464. mCannotBuyReason = getString("you_already_own");
  465. }
  466. return;
  467. }
  469. if (!authorizedBuyer.isNull()  &&  buyer != authorizedBuyer)
  470. {
  471. mCannotBuyReason = getString("set_to_sell_to_other");
  472. return;
  473. }
  474. }
  475. else
  476. {
  477. if (mParcelActualArea == 0)
  478. {
  479. mCannotBuyReason = getString("no_public_land");
  480. return;
  481. }
  483. if (mParcel->hasOthersSelected())
  484. {
  485. // Policy: Must not have someone else's land selected
  486. mCannotBuyReason = getString("not_owned_by_you");
  487. return;
  488. }
  489. }
  491. mCanBuy = true;
  492. }
  494. void LLFloaterBuyLandUI::updateCovenantInfo()
  495. {
  496. LLViewerRegion* region = LLViewerParcelMgr::getInstance()->getSelectionRegion();
  497. if(!region) return;
  499. U8 sim_access = region->getSimAccess();
  500. std::string rating = LLViewerRegion::accessToString(sim_access);
  502. LLTextBox* region_name = getChild<LLTextBox>("region_name_text");
  503. if (region_name)
  504. {
  505. std::string region_name_txt = region->getName() + " ("+rating +")";
  506. region_name->setText(region_name_txt);
  508. LLIconCtrl* rating_icon = getChild<LLIconCtrl>("rating_icon");
  509. LLRect rect = rating_icon->getRect();
  510. S32 icon_left_pad = region_name->getRect().mLeft + region_name->getTextBoundingRect().getWidth() + ICON_PAD;
  511. rating_icon->setRect(rect.setOriginAndSize(icon_left_pad, rect.mBottom, rect.getWidth(), rect.getHeight()));
  513. switch(sim_access)
  514. {
  515. case SIM_ACCESS_PG:
  516. rating_icon->setValue(getString("icon_PG"));
  517. break;
  519. case SIM_ACCESS_ADULT:
  520. rating_icon->setValue(getString("icon_R"));
  521. break;
  523. default:
  524. rating_icon->setValue(getString("icon_M"));
  525. }
  526. }
  528. LLTextBox* region_type = getChild<LLTextBox>("region_type_text");
  529. if (region_type)
  530. {
  531. region_type->setText(region->getSimProductName());
  532. }
  534. LLTextBox* resellable_clause = getChild<LLTextBox>("resellable_clause");
  535. if (resellable_clause)
  536. {
  537. if (region->getRegionFlags() & REGION_FLAGS_BLOCK_LAND_RESELL)
  538. {
  539. resellable_clause->setText(getString("can_not_resell"));
  540. }
  541. else
  542. {
  543. resellable_clause->setText(getString("can_resell"));
  544. }
  545. }
  547. LLTextBox* changeable_clause = getChild<LLTextBox>("changeable_clause");
  548. if (changeable_clause)
  549. {
  550. if (region->getRegionFlags() & REGION_FLAGS_ALLOW_PARCEL_CHANGES)
  551. {
  552. changeable_clause->setText(getString("can_change"));
  553. }
  554. else
  555. {
  556. changeable_clause->setText(getString("can_not_change"));
  557. }
  558. }
  560. LLCheckBoxCtrl* check = getChild<LLCheckBoxCtrl>("agree_covenant");
  561. if(check)
  562. {
  563. check->set(false);
  564. check->setEnabled(true);
  565. check->setCommitCallback(onChangeAgreeCovenant, this);
  566. }
  568. LLTextBox* box = getChild<LLTextBox>("covenant_text");
  569. if(box)
  570. {
  571. box->setVisible(FALSE);
  572. }
  574. // send EstateCovenantInfo message
  575. LLMessageSystem *msg = gMessageSystem;
  576. msg->newMessage("EstateCovenantRequest");
  577. msg->nextBlockFast(_PREHASH_AgentData);
  578. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  579. msg->addUUIDFast(_PREHASH_SessionID,gAgent.getSessionID());
  580. msg->sendReliable(region->getHost());
  581. }
  583. // static
  584. void LLFloaterBuyLandUI::onChangeAgreeCovenant(LLUICtrl* ctrl, void* user_data)
  585. {
  586. LLFloaterBuyLandUI* self = (LLFloaterBuyLandUI*)user_data;
  587. if(self)
  588. {
  589. self->refreshUI();
  590. }
  591. }
  593. void LLFloaterBuyLandUI::updateFloaterCovenantText(const std::string &string, const LLUUID& asset_id)
  594. {
  595. LLViewerTextEditor* editor = getChild<LLViewerTextEditor>("covenant_editor");
  596. editor->setText(string);
  598. LLCheckBoxCtrl* check = getChild<LLCheckBoxCtrl>("agree_covenant");
  599. LLTextBox* box = getChild<LLTextBox>("covenant_text");
  600. if (asset_id.isNull())
  601. {
  602. check->set(true);
  603. check->setEnabled(false);
  604. refreshUI();
  606. // remove the line stating that you must agree
  607. box->setVisible(FALSE);
  608. }
  609. else
  610. {
  611. check->setEnabled(true);
  613. // remove the line stating that you must agree
  614. box->setVisible(TRUE);
  615. }
  616. }
  618. void LLFloaterBuyLandUI::updateFloaterEstateName(const std::string& name)
  619. {
  620. LLTextBox* box = getChild<LLTextBox>("estate_name_text");
  621. if (box) box->setText(name);
  622. }
  624. void LLFloaterBuyLandUI::updateFloaterLastModified(const std::string& text)
  625. {
  626. LLTextBox* editor = getChild<LLTextBox>("covenant_timestamp_text");
  627. if (editor) editor->setText(text);
  628. }
  630. void LLFloaterBuyLandUI::updateFloaterEstateOwnerName(const std::string& name)
  631. {
  632. LLTextBox* box = getChild<LLTextBox>("estate_owner_text");
  633. if (box) box->setText(name);
  634. }
  636. void LLFloaterBuyLandUI::updateWebSiteInfo()
  637. {
  638. S32 askBillableArea = mIsForGroup ? 0 : mParcelBillableArea;
  639. S32 askCurrencyBuy = mCurrency.getAmount();
  641. if (mTransaction && mTransactionType == TransactionPreflight
  642. &&  mPreflightAskBillableArea == askBillableArea
  643. &&  mPreflightAskCurrencyBuy == askCurrencyBuy)
  644. {
  645. return;
  646. }
  648. mPreflightAskBillableArea = askBillableArea;
  649. mPreflightAskCurrencyBuy = askCurrencyBuy;
  651. #if 0
  652. // enable this code if you want the details to blank while we're talking
  653. // to the web site... it's kind of jarring
  654. mSiteValid = false;
  655. mSiteMembershipUpgrade = false;
  656. mSiteMembershipAction = "(waiting)";
  657. mSiteMembershipPlanIDs.clear();
  658. mSiteMembershipPlanNames.clear();
  659. mSiteLandUseUpgrade = false;
  660. mSiteLandUseAction = "(waiting)";
  661. mSiteCurrencyEstimated = false;
  662. mSiteCurrencyEstimatedCost = 0;
  663. #endif
  665. LLXMLRPCValue keywordArgs = LLXMLRPCValue::createStruct();
  666. keywordArgs.appendString("agentId", gAgent.getID().asString());
  667. keywordArgs.appendString(
  668. "secureSessionId",
  669. gAgent.getSecureSessionID().asString());
  670. keywordArgs.appendInt("billableArea", mPreflightAskBillableArea);
  671. keywordArgs.appendInt("currencyBuy", mPreflightAskCurrencyBuy);
  673. LLXMLRPCValue params = LLXMLRPCValue::createArray();
  674. params.append(keywordArgs);
  676. startTransaction(TransactionPreflight, params);
  677. }
  679. void LLFloaterBuyLandUI::finishWebSiteInfo()
  680. {
  682. LLXMLRPCValue result = mTransaction->responseValue();
  684. mSiteValid = result["success"].asBool();
  685. if (!mSiteValid)
  686. {
  687. tellUserError(
  688. result["errorMessage"].asString(),
  689. result["errorURI"].asString()
  690. );
  691. return;
  692. }
  694. LLXMLRPCValue membership = result["membership"];
  695. mSiteMembershipUpgrade = membership["upgrade"].asBool();
  696. mSiteMembershipAction = membership["action"].asString();
  697. mSiteMembershipPlanIDs.clear();
  698. mSiteMembershipPlanNames.clear();
  699. LLXMLRPCValue levels = membership["levels"];
  700. for (LLXMLRPCValue level = levels.rewind();
  701. level.isValid();
  702. level = levels.next())
  703. {
  704. mSiteMembershipPlanIDs.push_back(level["id"].asString());
  705. mSiteMembershipPlanNames.push_back(level["description"].asString());
  706. }
  707. mUserPlanChoice = 0;
  709. LLXMLRPCValue landUse = result["landUse"];
  710. mSiteLandUseUpgrade = landUse["upgrade"].asBool();
  711. mSiteLandUseAction = landUse["action"].asString();
  713. LLXMLRPCValue currency = result["currency"];
  714. if (currency["estimatedCost"].isValid())
  715. {
  716. mCurrency.setUSDEstimate(currency["estimatedCost"].asInt());
  717. }
  718. if (currency["estimatedLocalCost"].isValid())
  719. {
  720. mCurrency.setLocalEstimate(currency["estimatedLocalCost"].asString());
  721. }
  723. mSiteConfirm = result["confirm"].asString();
  724. }
  726. void LLFloaterBuyLandUI::runWebSitePrep(const std::string& password)
  727. {
  728. if (!mCanBuy)
  729. {
  730. return;
  731. }
  733. BOOL remove_contribution = childGetValue("remove_contribution").asBoolean();
  734. mParcelBuyInfo = LLViewerParcelMgr::getInstance()->setupParcelBuy(gAgent.getID(), gAgent.getSessionID(),
  735. gAgent.getGroupID(), mIsForGroup, mIsClaim, remove_contribution);
  737. if (mParcelBuyInfo
  738. && !mSiteMembershipUpgrade
  739. && !mSiteLandUseUpgrade
  740. && mCurrency.getAmount() == 0
  741. && mSiteConfirm != "password")
  742. {
  743. sendBuyLand();
  744. return;
  745. }
  748. std::string newLevel = "noChange";
  750. if (mSiteMembershipUpgrade)
  751. {
  752. LLComboBox* levels = getChild<LLComboBox>( "account_level");
  753. if (levels)
  754. {
  755. mUserPlanChoice = levels->getCurrentIndex();
  756. newLevel = mSiteMembershipPlanIDs[mUserPlanChoice];
  757. }
  758. }
  760. LLXMLRPCValue keywordArgs = LLXMLRPCValue::createStruct();
  761. keywordArgs.appendString("agentId", gAgent.getID().asString());
  762. keywordArgs.appendString(
  763. "secureSessionId",
  764. gAgent.getSecureSessionID().asString());
  765. keywordArgs.appendString("levelId", newLevel);
  766. keywordArgs.appendInt("billableArea",
  767. mIsForGroup ? 0 : mParcelBillableArea);
  768. keywordArgs.appendInt("currencyBuy", mCurrency.getAmount());
  769. keywordArgs.appendInt("estimatedCost", mCurrency.getUSDEstimate());
  770. keywordArgs.appendString("estimatedLocalCost", mCurrency.getLocalEstimate());
  771. keywordArgs.appendString("confirm", mSiteConfirm);
  772. if (!password.empty())
  773. {
  774. keywordArgs.appendString("password", password);
  775. }
  777. LLXMLRPCValue params = LLXMLRPCValue::createArray();
  778. params.append(keywordArgs);
  780. startTransaction(TransactionBuy, params);
  781. }
  783. void LLFloaterBuyLandUI::finishWebSitePrep()
  784. {
  785. LLXMLRPCValue result = mTransaction->responseValue();
  787. bool success = result["success"].asBool();
  788. if (!success)
  789. {
  790. tellUserError(
  791. result["errorMessage"].asString(),
  792. result["errorURI"].asString()
  793. );
  794. return;
  795. }
  797. sendBuyLand();
  798. }
  800. void LLFloaterBuyLandUI::sendBuyLand()
  801. {
  802. if (mParcelBuyInfo)
  803. {
  804. LLViewerParcelMgr::getInstance()->sendParcelBuy(mParcelBuyInfo);
  805. LLViewerParcelMgr::getInstance()->deleteParcelBuy(&mParcelBuyInfo);
  806. mBought = true;
  807. }
  808. }
  810. void LLFloaterBuyLandUI::updateNames()
  811. {
  812. LLParcel* parcelp = mParcel->getParcel();
  814. if (!parcelp)
  815. {
  816. mParcelSellerName = LLStringUtil::null;
  817. return;
  818. }
  820. if (mIsClaim)
  821. {
  822. mParcelSellerName = "Linden Lab";
  823. }
  824. else if (parcelp->getIsGroupOwned())
  825. {
  826. gCacheName->get(parcelp->getGroupID(), TRUE,
  827. boost::bind(&LLFloaterBuyLandUI::updateGroupName, this,
  828. _1, _2, _3, _4));
  829. }
  830. else
  831. {
  832. mParcelSellerName =
  833. LLSLURL::buildCommand("agent", parcelp->getOwnerID(), "inspect");
  834. }
  835. }
  837. void LLFloaterBuyLandUI::updateGroupName(const LLUUID& id,
  838.  const std::string& first_name,
  839.  const std::string& last_name,
  840.  BOOL is_group)
  841. {
  842. LLParcel* parcelp = mParcel->getParcel();
  843. if (parcelp
  844. && parcelp->getGroupID() == id)
  845. {
  846. // request is current
  847. mParcelSellerName = first_name;
  848. }
  849. }
  851. void LLFloaterBuyLandUI::startTransaction(TransactionType type, const LLXMLRPCValue& params)
  852. {
  853. delete mTransaction;
  854. mTransaction = NULL;
  856. mTransactionType = type;
  858. // Select a URI and method appropriate for the transaction type.
  859. static std::string transaction_uri;
  860. if (transaction_uri.empty())
  861. {
  862. transaction_uri = LLViewerLogin::getInstance()->getHelperURI() + "landtool.php";
  863. }
  865. const char* method;
  866. switch (mTransactionType)
  867. {
  868. case TransactionPreflight:
  869. method = "preflightBuyLandPrep";
  870. break;
  871. case TransactionBuy:
  872. method = "buyLandPrep";
  873. break;
  874. default:
  875. llwarns << "LLFloaterBuyLandUI: Unknown transaction type!" << llendl;
  876. return;
  877. }
  879. mTransaction = new LLXMLRPCTransaction(
  880. transaction_uri,
  881. method,
  882. params,
  883. false /* don't use gzip */
  884. );
  885. }
  887. bool LLFloaterBuyLandUI::checkTransaction()
  888. {
  889. if (!mTransaction)
  890. {
  891. return false;
  892. }
  894. if (!mTransaction->process())
  895. {
  896. return false;
  897. }
  899. if (mTransaction->status(NULL) != LLXMLRPCTransaction::StatusComplete)
  900. {
  901. tellUserError(mTransaction->statusMessage(), mTransaction->statusURI());
  902. }
  903. else {
  904. switch (mTransactionType)
  905. {
  906. case TransactionPreflight: finishWebSiteInfo(); break;
  907. case TransactionBuy: finishWebSitePrep(); break;
  908. default: ;
  909. }
  910. }
  912. delete mTransaction;
  913. mTransaction = NULL;
  915. return true;
  916. }
  918. void LLFloaterBuyLandUI::tellUserError(
  919. const std::string& message, const std::string& uri)
  920. {
  921. mCanBuy = false;
  922. mCannotBuyIsError = true;
  923. mCannotBuyReason = getString("fetching_error");
  924. mCannotBuyReason += message;
  925. mCannotBuyURI = uri;
  926. }
  929. // virtual
  930. BOOL LLFloaterBuyLandUI::postBuild()
  931. {
  932. setVisibleCallback(boost::bind(&LLFloaterBuyLandUI::onVisibilityChange, this, _2));
  934. mCurrency.prepare();
  936. getChild<LLUICtrl>("buy_btn")->setCommitCallback( boost::bind(&LLFloaterBuyLandUI::onClickBuy, this));
  937. getChild<LLUICtrl>("cancel_btn")->setCommitCallback( boost::bind(&LLFloaterBuyLandUI::onClickCancel, this));
  938. getChild<LLUICtrl>("error_web")->setCommitCallback( boost::bind(&LLFloaterBuyLandUI::onClickErrorWeb, this));
  940. center();
  942. return TRUE;
  943. }
  945. void LLFloaterBuyLandUI::setParcel(LLViewerRegion* region, LLParcelSelectionHandle parcel)
  946. {
  947. if (mTransaction &&  mTransactionType == TransactionBuy)
  948. {
  949. // the user is buying, don't change the selection
  950. return;
  951. }
  953. mRegion = region;
  954. mParcel = parcel;
  956. updateAgentInfo();
  957. updateParcelInfo();
  958. updateCovenantInfo();
  959. if (mCanBuy)
  960. {
  961. updateWebSiteInfo();
  962. }
  963. refreshUI();
  964. }
  966. void LLFloaterBuyLandUI::setForGroup(bool forGroup)
  967. {
  968. mIsForGroup = forGroup;
  969. }
  971. void LLFloaterBuyLandUI::draw()
  972. {
  973. LLFloater::draw();
  975. bool needsUpdate = false;
  976. needsUpdate |= checkTransaction();
  977. needsUpdate |= mCurrency.process();
  979. if (mBought)
  980. {
  981. closeFloater();
  982. }
  983. else if (needsUpdate)
  984. {
  985. if (mCanBuy && mCurrency.hasError())
  986. {
  987. tellUserError(mCurrency.errorMessage(), mCurrency.errorURI());
  988. }
  990. refreshUI();
  991. }
  992. }
  994. // virtual
  995. BOOL LLFloaterBuyLandUI::canClose()
  996. {
  997. bool can_close = (mTransaction ? FALSE : TRUE) && mCurrency.canCancel();
  998. if (!can_close)
  999. {
  1000. // explain to user why they can't do this, see DEV-9605
  1001. LLNotificationsUtil::add("CannotCloseFloaterBuyLand");
  1002. }
  1003. return can_close;
  1004. }
  1006. void LLFloaterBuyLandUI::onVisibilityChange ( const LLSD& new_visibility )
  1007. {
  1008. if (new_visibility.asBoolean())
  1009. {
  1010. refreshUI();
  1011. }
  1012. }
  1014. void LLFloaterBuyLandUI::refreshUI()
  1015. {
  1016. // section zero: title area
  1017. {
  1018. LLTextureCtrl* snapshot = getChild<LLTextureCtrl>("info_image");
  1019. if (snapshot)
  1020. {
  1021. snapshot->setImageAssetID(
  1022. mParcelValid ? mParcelSnapshot : LLUUID::null);
  1023. }
  1025. if (mParcelValid)
  1026. {
  1027. childSetText("info_parcel", mParcelLocation);
  1029. LLStringUtil::format_map_t string_args;
  1030. string_args["[AMOUNT]"] = llformat("%d", mParcelActualArea);
  1031. string_args["[AMOUNT2]"] = llformat("%d", mParcelSupportedObjects);
  1033. childSetText("info_size", getString("meters_supports_object", string_args));
  1035. F32 cost_per_sqm = 0.0f;
  1036. if (mParcelActualArea > 0)
  1037. {
  1038. cost_per_sqm = (F32)mParcelPrice / (F32)mParcelActualArea;
  1039. }
  1041. LLStringUtil::format_map_t info_price_args;
  1042. info_price_args["[PRICE]"] = llformat("%d", mParcelPrice);
  1043. info_price_args["[PRICE_PER_SQM]"] = llformat("%.1f", cost_per_sqm);
  1044. if (mParcelSoldWithObjects)
  1045. {
  1046. info_price_args["[SOLD_WITH_OBJECTS]"] = getString("sold_with_objects");
  1047. }
  1048. else
  1049. {
  1050. info_price_args["[SOLD_WITH_OBJECTS]"] = getString("sold_without_objects");
  1051. }
  1052. childSetText("info_price", getString("info_price_string", info_price_args));
  1053. childSetVisible("info_price", mParcelIsForSale);
  1054. }
  1055. else
  1056. {
  1057. childSetText("info_parcel", getString("no_parcel_selected"));
  1058. childSetText("info_size", LLStringUtil::null);
  1059. childSetText("info_price", LLStringUtil::null);
  1060. }
  1062. childSetText("info_action",
  1063. mCanBuy
  1064. ?
  1065. mIsForGroup
  1066. ? getString("buying_for_group")//"Buying land for group:"
  1067. : getString("buying_will")//"Buying this land will:"
  1068. : 
  1069. mCannotBuyIsError
  1070. ? getString("cannot_buy_now")//"Cannot buy now:"
  1071. : getString("not_for_sale")//"Not for sale:"
  1073. );
  1074. }
  1076. bool showingError = !mCanBuy || !mSiteValid;
  1078. // error section
  1079. if (showingError)
  1080. {
  1081. mChildren.setBadge(std::string("step_error"),
  1082. mCannotBuyIsError
  1083. ? LLViewChildren::BADGE_ERROR
  1084. : LLViewChildren::BADGE_WARN);
  1086. LLTextBox* message = getChild<LLTextBox>("error_message");
  1087. if (message)
  1088. {
  1089. message->setVisible(true);
  1090. message->setValue(LLSD(!mCanBuy ? mCannotBuyReason : "(waiting for data)"));
  1091. }
  1093. childSetVisible("error_web", 
  1094. mCannotBuyIsError && !mCannotBuyURI.empty());
  1095. }
  1096. else
  1097. {
  1098. childHide("step_error");
  1099. childHide("error_message");
  1100. childHide("error_web");
  1101. }
  1104. // section one: account
  1105. if (!showingError)
  1106. {
  1107. mChildren.setBadge(std::string("step_1"),
  1108. mSiteMembershipUpgrade
  1109. ? LLViewChildren::BADGE_NOTE
  1110. : LLViewChildren::BADGE_OK);
  1111. childSetText("account_action", mSiteMembershipAction);
  1112. childSetText("account_reason", 
  1113. mSiteMembershipUpgrade
  1114. ? getString("must_upgrade")
  1115. : getString("cant_own_land")
  1116. );
  1118. LLComboBox* levels = getChild<LLComboBox>( "account_level");
  1119. if (levels)
  1120. {
  1121. levels->setVisible(mSiteMembershipUpgrade);
  1123. levels->removeall();
  1124. for(std::vector<std::string>::const_iterator i
  1125. = mSiteMembershipPlanNames.begin();
  1126. i != mSiteMembershipPlanNames.end();
  1127. ++i)
  1128. {
  1129. levels->add(*i);
  1130. }
  1132. levels->setCurrentByIndex(mUserPlanChoice);
  1133. }
  1135. childShow("step_1");
  1136. childShow("account_action");
  1137. childShow("account_reason");
  1138. }
  1139. else
  1140. {
  1141. childHide("step_1");
  1142. childHide("account_action");
  1143. childHide("account_reason");
  1144. childHide("account_level");
  1145. }
  1147. // section two: land use fees
  1148. if (!showingError)
  1149. {
  1150. mChildren.setBadge(std::string("step_2"),
  1151. mSiteLandUseUpgrade
  1152. ? LLViewChildren::BADGE_NOTE
  1153. : LLViewChildren::BADGE_OK);
  1154. childSetText("land_use_action", mSiteLandUseAction);
  1156. std::string message;
  1158. if (mIsForGroup)
  1159. {
  1160. LLStringUtil::format_map_t string_args;
  1161. string_args["[GROUP]"] = std::string(gAgent.getGroupName());
  1163. message += getString("insufficient_land_credits", string_args);
  1165. }
  1166. else
  1167. {
  1168. LLStringUtil::format_map_t string_args;
  1169. string_args["[BUYER]"] = llformat("%d", mAgentCommittedTier);
  1170. message += getString("land_holdings", string_args);
  1171. }
  1173. if (!mParcelValid)
  1174. {
  1175. message += getString("no_parcel_selected");
  1176. }
  1177. else if (mParcelBillableArea == mParcelActualArea)
  1178. {
  1179. LLStringUtil::format_map_t string_args;
  1180. string_args["[AMOUNT]"] = llformat("%d ", mParcelActualArea);
  1181. message += getString("parcel_meters", string_args);
  1182. }
  1183. else
  1184. {
  1186. if (mParcelBillableArea > mParcelActualArea)
  1187. {
  1188. LLStringUtil::format_map_t string_args;
  1189. string_args["[AMOUNT]"] = llformat("%d ", mParcelBillableArea);
  1190. message += getString("premium_land", string_args);
  1191. }
  1192. else
  1193. {
  1194. LLStringUtil::format_map_t string_args;
  1195. string_args["[AMOUNT]"] = llformat("%d ", mParcelBillableArea);
  1196. message += getString("discounted_land", string_args);
  1197. }
  1198. }
  1200. childSetValue("land_use_reason", message);
  1202. childShow("step_2");
  1203. childShow("land_use_action");
  1204. childShow("land_use_reason");
  1205. }
  1206. else
  1207. {
  1208. childHide("step_2");
  1209. childHide("land_use_action");
  1210. childHide("land_use_reason");
  1211. }
  1213. // section three: purchase & currency
  1214. S32 finalBalance = mAgentCashBalance + mCurrency.getAmount() - mParcelPrice;
  1215. bool willHaveEnough = finalBalance >= 0;
  1216. bool haveEnough = mAgentCashBalance >= mParcelPrice;
  1217. S32 minContribution = llceil((F32)mParcelBillableArea / GROUP_LAND_BONUS_FACTOR);
  1218. bool groupContributionEnough = mParcelGroupContribution >= minContribution;
  1220. mCurrency.updateUI(!showingError  &&  !haveEnough);
  1222. if (!showingError)
  1223. {
  1224. mChildren.setBadge(std::string("step_3"),
  1225. !willHaveEnough
  1226. ? LLViewChildren::BADGE_WARN
  1227. : mCurrency.getAmount() > 0
  1228. ? LLViewChildren::BADGE_NOTE
  1229. : LLViewChildren::BADGE_OK);
  1231. LLStringUtil::format_map_t string_args;
  1232. string_args["[AMOUNT]"] = llformat("%d", mParcelPrice);
  1233. string_args["[SELLER]"] = mParcelSellerName;
  1234. childSetText("purchase_action", getString("pay_to_for_land", string_args));
  1235. childSetVisible("purchase_action", mParcelValid);
  1237. std::string reasonString;
  1239. if (haveEnough)
  1240. {
  1241. LLStringUtil::format_map_t string_args;
  1242. string_args["[AMOUNT]"] = llformat("%d", mAgentCashBalance);
  1244. childSetText("currency_reason", getString("have_enough_lindens", string_args));
  1245. }
  1246. else
  1247. {
  1248. LLStringUtil::format_map_t string_args;
  1249. string_args["[AMOUNT]"] = llformat("%d", mAgentCashBalance);
  1250. string_args["[AMOUNT2]"] = llformat("%d", mParcelPrice - mAgentCashBalance);
  1252. childSetText("currency_reason", getString("not_enough_lindens", string_args));
  1254. childSetTextArg("currency_est", "[LOCAL_AMOUNT]", mCurrency.getLocalEstimate());
  1255. }
  1257. if (willHaveEnough)
  1258. {
  1259. LLStringUtil::format_map_t string_args;
  1260. string_args["[AMOUNT]"] = llformat("%d", finalBalance);
  1262. childSetText("currency_balance", getString("balance_left", string_args));
  1264. }
  1265. else
  1266. {
  1267. LLStringUtil::format_map_t string_args;
  1268. string_args["[AMOUNT]"] = llformat("%d", mParcelPrice - mAgentCashBalance);
  1270. childSetText("currency_balance", getString("balance_needed", string_args));
  1272. }
  1274. childSetValue("remove_contribution", LLSD(groupContributionEnough));
  1275. childSetEnabled("remove_contribution", groupContributionEnough);
  1276. bool showRemoveContribution = mParcelIsGroupLand
  1277. && (mParcelGroupContribution > 0);
  1278. childSetLabelArg("remove_contribution", "[AMOUNT]",
  1279. llformat("%d", minContribution));
  1280. childSetVisible("remove_contribution", showRemoveContribution);
  1282. childShow("step_3");
  1283. childShow("purchase_action");
  1284. childShow("currency_reason");
  1285. childShow("currency_balance");
  1286. }
  1287. else
  1288. {
  1289. childHide("step_3");
  1290. childHide("purchase_action");
  1291. childHide("currency_reason");
  1292. childHide("currency_balance");
  1293. childHide("remove_group_donation");
  1294. }
  1297. bool agrees_to_covenant = false;
  1298. LLCheckBoxCtrl* check = getChild<LLCheckBoxCtrl>("agree_covenant");
  1299. if (check)
  1300. {
  1301.     agrees_to_covenant = check->get();
  1302. }
  1304. childSetEnabled("buy_btn",
  1305. mCanBuy  &&  mSiteValid  &&  willHaveEnough  &&  !mTransaction && agrees_to_covenant);
  1306. }
  1308. void LLFloaterBuyLandUI::startBuyPreConfirm()
  1309. {
  1310. std::string action;
  1312. if (mSiteMembershipUpgrade)
  1313. {
  1314. action += mSiteMembershipAction;
  1315. action += "n";
  1317. LLComboBox* levels = getChild<LLComboBox>( "account_level");
  1318. if (levels)
  1319. {
  1320. action += " * ";
  1321. action += mSiteMembershipPlanNames[levels->getCurrentIndex()];
  1322. action += "n";
  1323. }
  1324. }
  1325. if (mSiteLandUseUpgrade)
  1326. {
  1327. action += mSiteLandUseAction;
  1328. action += "n";
  1329. }
  1330. if (mCurrency.getAmount() > 0)
  1331. {
  1332. LLStringUtil::format_map_t string_args;
  1333. string_args["[AMOUNT]"] = llformat("%d", mCurrency.getAmount());
  1334. string_args["[LOCAL_AMOUNT]"] = mCurrency.getLocalEstimate();
  1336. action += getString("buy_for_US", string_args);
  1337. }
  1339. LLStringUtil::format_map_t string_args;
  1340. string_args["[AMOUNT]"] = llformat("%d", mParcelPrice);
  1341. string_args["[SELLER]"] = mParcelSellerName;
  1342. action += getString("pay_to_for_land", string_args);
  1345. LLConfirmationManager::confirm(mSiteConfirm,
  1346. action,
  1347. *this,
  1348. &LLFloaterBuyLandUI::startBuyPostConfirm);
  1349. }
  1351. void LLFloaterBuyLandUI::startBuyPostConfirm(const std::string& password)
  1352. {
  1353. runWebSitePrep(password);
  1355. mCanBuy = false;
  1356. mCannotBuyReason = getString("processing");
  1357. refreshUI();
  1358. }
  1361. void LLFloaterBuyLandUI::onClickBuy()
  1362. {
  1363. startBuyPreConfirm();
  1364. }
  1366. void LLFloaterBuyLandUI::onClickCancel()
  1367. {
  1368. closeFloater();
  1369. }
  1371. void LLFloaterBuyLandUI::onClickErrorWeb()
  1372. {
  1373. LLWeb::loadURLExternal(mCannotBuyURI);
  1374. closeFloater();
  1375. }