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

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

游戏引擎

开发平台：

C++ Builder

llpanelgrouplandmoney.cpp：源码内容
  1. /** 
  2.  * @file llpanelgrouplandmoney.cpp
  3.  * @brief Panel for group land and L$.
  4.  *
  5.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2006-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 "llpanelgrouplandmoney.h"
  37. #include "lluiconstants.h"
  38. #include "roles_constants.h"
  40. #include "llparcel.h"
  41. #include "llqueryflags.h"
  43. #include "llagent.h"
  44. #include "lliconctrl.h"
  45. #include "llfloaterreg.h"
  46. #include "lllineeditor.h"
  47. #include "llproductinforequest.h"
  48. #include "llscrolllistctrl.h"
  49. #include "llscrolllistitem.h"
  50. #include "llscrolllistcell.h"
  51. #include "lltextbox.h"
  52. #include "lltabcontainer.h"
  53. #include "lltexteditor.h"
  54. #include "lltrans.h"
  55. #include "lltransactiontypes.h"
  56. #include "lltrans.h"
  57. #include "lluictrlfactory.h"
  59. #include "llstatusbar.h"
  60. #include "llfloaterworldmap.h"
  61. #include "llviewermessage.h"
  63. static LLRegisterPanelClassWrapper<LLPanelGroupLandMoney> t_panel_group_money("panel_group_land_money");
  67. ////////////////////////////////////////////////////////////////////////////
  68. //*************************************************
  69. //** LLGroupMoneyTabEventHandler::impl Functions **
  70. //*************************************************
  72. class LLGroupMoneyTabEventHandlerImpl
  73. {
  74. public:
  75. LLGroupMoneyTabEventHandlerImpl(LLButton* earlier_buttonp,
  76.  LLButton* later_buttonp,
  77.  LLTextEditor* text_editorp,
  78.  LLPanel* tabpanelp,
  79.  const std::string& loading_text,
  80.  S32 interval_length_days,
  81.  S32 max_interval_days);
  82. ~LLGroupMoneyTabEventHandlerImpl();
  84. bool getCanClickLater();
  85. bool getCanClickEarlier();
  87. void updateButtons();
  89. void setGroupID(const LLUUID& group_id) { mGroupID = group_id; } ;
  90. const LLUUID& getGroupID() const { return mGroupID;} 
  93. //member variables
  94. public:
  95. LLUUID mPanelID;
  96. LLUUID mGroupID;
  98. LLPanel* mTabPanelp;
  100. int mIntervalLength;
  101. int mMaxInterval;
  102. int mCurrentInterval;
  104. LLTextEditor* mTextEditorp;
  105. LLButton*     mEarlierButtonp;
  106. LLButton*     mLaterButtonp;
  108. std::string mLoadingText;
  109. };
  112. class LLGroupMoneyTabEventHandler
  113. {
  114. public:
  115. LLGroupMoneyTabEventHandler(LLButton* earlier_button,
  116. LLButton* later_button,
  117. LLTextEditor* text_editor,
  118. LLTabContainer* tab_containerp,
  119. LLPanel* panelp,
  120. const std::string& loading_text,
  121. S32 interval_length_days,
  122. S32 max_interval_days);
  123. virtual ~LLGroupMoneyTabEventHandler();
  125. virtual void requestData(LLMessageSystem* msg);
  126. virtual void processReply(LLMessageSystem* msg, void** data);
  128. virtual void onClickEarlier();
  129. virtual void onClickLater();
  130. virtual void onClickTab();
  132. void setGroupID(const LLUUID& group_id) { if(mImplementationp) mImplementationp->setGroupID(group_id); } ;
  134. static void clickEarlierCallback(void* data);
  135. static void clickLaterCallback(void* data);
  139. static LLMap<LLUUID, LLGroupMoneyTabEventHandler*> sInstanceIDs;
  140. static std::map<LLPanel*, LLGroupMoneyTabEventHandler*> sTabsToHandlers;
  141. protected:
  142. LLGroupMoneyTabEventHandlerImpl* mImplementationp;
  143. };
  145. class LLGroupMoneyDetailsTabEventHandler : public LLGroupMoneyTabEventHandler
  146. {
  147. public:
  148. LLGroupMoneyDetailsTabEventHandler(LLButton* earlier_buttonp,
  149.    LLButton* later_buttonp,
  150.    LLTextEditor* text_editorp,
  151.    LLTabContainer* tab_containerp,
  152.    LLPanel* panelp,
  153.    const std::string& loading_text
  154.    );
  155. virtual ~LLGroupMoneyDetailsTabEventHandler();
  157. virtual void requestData(LLMessageSystem* msg);
  158. virtual void processReply(LLMessageSystem* msg, void** data);
  159. };
  162. class LLGroupMoneySalesTabEventHandler : public LLGroupMoneyTabEventHandler
  163. {
  164. public:
  165. LLGroupMoneySalesTabEventHandler(LLButton* earlier_buttonp,
  166.  LLButton* later_buttonp,
  167.  LLTextEditor* text_editorp,
  168.  LLTabContainer* tab_containerp,
  169.  LLPanel* panelp,
  170.  const std::string& loading_text
  171.  );
  172. virtual ~LLGroupMoneySalesTabEventHandler();
  174. virtual void requestData(LLMessageSystem* msg);
  175. virtual void processReply(LLMessageSystem* msg, void** data);
  176. };
  178. class LLGroupMoneyPlanningTabEventHandler : public LLGroupMoneyTabEventHandler
  179. {
  180. public:
  181. LLGroupMoneyPlanningTabEventHandler(LLTextEditor* text_editor,
  182. LLTabContainer* tab_containerp,
  183. LLPanel* panelp,
  184. const std::string& loading_text
  185. );
  186. virtual ~LLGroupMoneyPlanningTabEventHandler();
  188. virtual void requestData(LLMessageSystem* msg);
  189. virtual void processReply(LLMessageSystem* msg, void** data);
  190. };
  192. ////////////////////////////////////////////////////////////////////////////
  194. class LLPanelGroupLandMoney::impl
  195. {
  196. public:
  197. impl(LLPanelGroupLandMoney& panel); //constructor
  198. virtual ~impl();
  200. void requestGroupLandInfo();
  202. int getStoredContribution();
  203. void setYourContributionTextField(int contrib);
  204. void setYourMaxContributionTextBox(int max);
  206. virtual void onMapButton();
  207. virtual bool applyContribution();
  208. virtual void processGroupLand(LLMessageSystem* msg);
  210. static void mapCallback(void* data);
  211. static void contributionCommitCallback(LLUICtrl* ctrl, void* userdata);
  212. static void contributionKeystrokeCallback(LLLineEditor* caller, void* userdata);
  214. //member variables
  215. public:
  216. LLPanelGroupLandMoney& mPanel;
  218. LLTextBox* mGroupOverLimitTextp;
  219. LLIconCtrl* mGroupOverLimitIconp;
  221. LLLineEditor* mYourContributionEditorp;
  223. LLButton* mMapButtonp;
  225. LLGroupMoneyTabEventHandler* mMoneyDetailsTabEHp;
  226. LLGroupMoneyTabEventHandler* mMoneyPlanningTabEHp;
  227. LLGroupMoneyTabEventHandler* mMoneySalesTabEHp;
  229. LLScrollListCtrl* mGroupParcelsp;
  231. LLUUID mTransID;
  233. bool mBeenActivated;
  234. bool mNeedsSendGroupLandRequest;
  235. bool mNeedsApply;
  237. std::string mCantViewParcelsText;
  238. std::string mCantViewAccountsText;
  239. };
  241. //*******************************************
  242. //** LLPanelGroupLandMoney::impl Functions **
  243. //*******************************************
  244. LLPanelGroupLandMoney::impl::impl(LLPanelGroupLandMoney& panel)
  245. : mPanel(panel)
  246. {
  247. mTransID = LLUUID::null;
  249. mBeenActivated = false;
  250. mNeedsSendGroupLandRequest = true;
  251. mNeedsApply = false;
  253. mYourContributionEditorp = NULL;
  254. mMapButtonp = NULL;
  255. mGroupParcelsp = NULL;
  256. mGroupOverLimitTextp = NULL;
  257. mGroupOverLimitIconp = NULL;
  259. mMoneySalesTabEHp    = NULL;
  260. mMoneyPlanningTabEHp = NULL;
  261. mMoneyDetailsTabEHp  = NULL;
  262. }
  264. LLPanelGroupLandMoney::impl::~impl()
  265. {
  266. if ( mMoneySalesTabEHp ) delete mMoneySalesTabEHp;
  267. if ( mMoneyDetailsTabEHp ) delete mMoneyDetailsTabEHp;
  268. if ( mMoneyPlanningTabEHp ) delete mMoneyPlanningTabEHp;
  269. }
  271. void LLPanelGroupLandMoney::impl::requestGroupLandInfo()
  272. {
  273. U32 query_flags = DFQ_GROUP_OWNED;
  275. mTransID.generate();
  276. mGroupParcelsp->deleteAllItems();
  278. send_places_query(mPanel.mGroupID, mTransID, "", query_flags, LLParcel::C_ANY, "");
  279. }
  281. void LLPanelGroupLandMoney::impl::onMapButton()
  282. {
  283. LLScrollListItem* itemp;
  284. itemp = mGroupParcelsp->getFirstSelected();
  285. if (!itemp) return;
  287. const LLScrollListCell* cellp;
  288. cellp = itemp->getColumn(itemp->getNumColumns() - 1); // hidden column is last
  290. F32 global_x = 0.f;
  291. F32 global_y = 0.f;
  292. sscanf(cellp->getValue().asString().c_str(), "%f %f", &global_x, &global_y);
  294. // Hack: Use the agent's z-height
  295. F64 global_z = gAgent.getPositionGlobal().mdV[VZ];
  297. LLVector3d pos_global(global_x, global_y, global_z);
  298. LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
  299.     if(worldmap_instance)
  300. {
  301. worldmap_instance->trackLocation(pos_global);
  302. LLFloaterReg::showInstance("world_map", "center");
  303. }
  304. }
  306. bool LLPanelGroupLandMoney::impl::applyContribution()
  307. {
  308. // calculate max donation, which is sum of available and current.
  309. S32 your_contribution = 0;
  310. S32 sqm_avail;
  312. your_contribution = getStoredContribution();
  313. sqm_avail = your_contribution;
  315. if(gStatusBar)
  316. {
  317. sqm_avail += gStatusBar->getSquareMetersLeft();
  318. }
  320. // get new contribution and compare to available
  321. S32 new_contribution = atoi(mYourContributionEditorp->getText().c_str());
  323. if( new_contribution != your_contribution &&
  324. new_contribution >= 0 && 
  325.     new_contribution <= sqm_avail )
  326. {
  327. // update group info and server
  328. if(!gAgent.setGroupContribution(mPanel.mGroupID, new_contribution))
  329. {
  330. // should never happen...
  331. llwarns << "Unable to set contribution." << llendl;
  332. return false;
  333. }
  334. }
  335. else
  336. {
  337. //TODO: throw up some error message here and return?  right now we just
  338. //fail silently and force the previous value  -jwolk
  339. new_contribution =  your_contribution;
  340. }
  342. //set your contribution
  343. setYourContributionTextField(new_contribution);
  345. return true;
  346. }
  348. // Retrieves the land contribution for this agent that is currently
  349. // stored in the database, NOT what is currently entered in the text field
  350. int LLPanelGroupLandMoney::impl::getStoredContribution()
  351. {
  352. LLGroupData group_data;
  354. group_data.mContribution = 0;
  355. gAgent.getGroupData(mPanel.mGroupID, group_data);
  357. return group_data.mContribution;
  358. }
  360. // Fills in the text field with the contribution, contrib
  361. void LLPanelGroupLandMoney::impl::setYourContributionTextField(int contrib)
  362. {
  363. std::string buffer = llformat("%d", contrib);
  365. if ( mYourContributionEditorp )
  366. {
  367. mYourContributionEditorp->setText(buffer);
  368. }
  369. }
  371. void LLPanelGroupLandMoney::impl::setYourMaxContributionTextBox(int max)
  372. {
  373. mPanel.childSetTextArg("your_contribution_max_value", "[AMOUNT]", llformat("%d", max));
  374. }
  376. //static
  377. void LLPanelGroupLandMoney::impl::mapCallback(void* data)
  378. {
  379. LLPanelGroupLandMoney::impl* selfp = (LLPanelGroupLandMoney::impl*) data;
  381. if ( selfp ) selfp->onMapButton();
  382. }
  384. void LLPanelGroupLandMoney::impl::contributionCommitCallback(LLUICtrl* ctrl, 
  385.  void* userdata)
  386. {
  387. LLPanelGroupLandMoney* tabp    = (LLPanelGroupLandMoney*) userdata;
  388. LLLineEditor*          editorp = (LLLineEditor*) ctrl;
  390. if ( tabp && editorp )
  391. {
  392. impl* self = tabp->mImplementationp;
  393. int your_contribution = 0;
  394. int new_contribution = 0;
  396. new_contribution= atoi(editorp->getText().c_str());
  397. your_contribution = self->getStoredContribution();
  399. //reset their junk data to be "good" data to us
  400. self->setYourContributionTextField(new_contribution);
  402. //check to see if they're contribution text has changed
  403. self->mNeedsApply = new_contribution != your_contribution;
  404. tabp->notifyObservers();
  405. }
  406. }
  408. void LLPanelGroupLandMoney::impl::contributionKeystrokeCallback(LLLineEditor* caller,
  409. void* userdata)
  410. {
  411. impl::contributionCommitCallback(caller, userdata);
  412. }
  414. //static
  415. void LLPanelGroupLandMoney::impl::processGroupLand(LLMessageSystem* msg)
  416. {
  417. S32 count = msg->getNumberOfBlocks("QueryData");
  418. if(count > 0)
  419. {
  420. S32 first_block = 0;
  422. LLUUID owner_id;
  423. LLUUID trans_id;
  425. msg->getUUID("QueryData", "OwnerID", owner_id, 0);
  426. msg->getUUID("TransactionData", "TransactionID", trans_id);
  428. if(owner_id.isNull())
  429. {
  430. // special block which has total contribution
  431. ++first_block;
  433. S32 total_contribution;
  434. msg->getS32("QueryData", "ActualArea", total_contribution, 0);
  435. mPanel.childSetTextArg("total_contributed_land_value", "[AREA]", llformat("%d", total_contribution));
  437. S32 committed;
  438. msg->getS32("QueryData", "BillableArea", committed, 0);
  439. mPanel.childSetTextArg("total_land_in_use_value", "[AREA]", llformat("%d", committed));
  441. S32 available = total_contribution - committed;
  442. mPanel.childSetTextArg("land_available_value", "[AREA]", llformat("%d", available));
  444. if ( mGroupOverLimitTextp && mGroupOverLimitIconp )
  445. {
  446. mGroupOverLimitIconp->setVisible(available < 0);
  447. mGroupOverLimitTextp->setVisible(available < 0);
  448. }
  449. }
  451. if ( trans_id != mTransID ) return;
  452. // This power was removed to make group roles simpler
  453. //if ( !gAgent.hasPowerInGroup(mGroupID, GP_LAND_VIEW_OWNED) ) return;
  454. if (!gAgent.isInGroup(mPanel.mGroupID)) return;
  456. std::string name;
  457. std::string desc;
  458. S32 actual_area;
  459. S32 billable_area;
  460. U8 flags;
  461. F32 global_x;
  462. F32 global_y;
  463. std::string sim_name;
  464. std::string land_sku;
  465. std::string land_type;
  467. for(S32 i = first_block; i < count; ++i)
  468. {
  469. msg->getUUID("QueryData", "OwnerID", owner_id, i);
  470. msg->getString("QueryData", "Name", name, i);
  471. msg->getString("QueryData", "Desc", desc, i);
  472. msg->getS32("QueryData", "ActualArea", actual_area, i);
  473. msg->getS32("QueryData", "BillableArea", billable_area, i);
  474. msg->getU8("QueryData", "Flags", flags, i);
  475. msg->getF32("QueryData", "GlobalX", global_x, i);
  476. msg->getF32("QueryData", "GlobalY", global_y, i);
  477. msg->getString("QueryData", "SimName", sim_name, i);
  479. if ( msg->getSizeFast(_PREHASH_QueryData, i, _PREHASH_ProductSKU) > 0 )
  480. {
  481. msg->getStringFast( _PREHASH_QueryData, _PREHASH_ProductSKU, land_sku, i);
  482. llinfos << "Land sku: " << land_sku << llendl;
  483. land_type = LLProductInfoRequestManager::instance().getDescriptionForSku(land_sku);
  484. }
  485. else
  486. {
  487. land_sku.clear();
  488. land_type = LLTrans::getString("land_type_unknown");
  489. }
  491. S32 region_x = llround(global_x) % REGION_WIDTH_UNITS;
  492. S32 region_y = llround(global_y) % REGION_WIDTH_UNITS;
  493. std::string location = sim_name + llformat(" (%d, %d)", region_x, region_y);
  494. std::string area;
  495. if(billable_area == actual_area)
  496. {
  497. area = llformat("%d", billable_area);
  498. }
  499. else
  500. {
  501. area = llformat("%d / %d", billable_area, actual_area);
  502. }
  504. std::string hidden;
  505. hidden = llformat("%f %f", global_x, global_y);
  507. LLSD row;
  509. row["columns"][0]["column"] = "name";
  510. row["columns"][0]["value"] = name;
  511. row["columns"][0]["font"] = "SANSSERIF_SMALL";
  513. row["columns"][1]["column"] = "location";
  514. row["columns"][1]["value"] = location;
  515. row["columns"][1]["font"] = "SANSSERIF_SMALL";
  517. row["columns"][2]["column"] = "area";
  518. row["columns"][2]["value"] = area;
  519. row["columns"][2]["font"] = "SANSSERIF_SMALL";
  521. row["columns"][3]["column"] = "type";
  522. row["columns"][3]["value"] = land_type;
  523. row["columns"][3]["font"] = "SANSSERIFSMALL";
  525. // hidden is always last column
  526. row["columns"][4]["column"] = "hidden";
  527. row["columns"][4]["value"] = hidden;
  529. mGroupParcelsp->addElement(row, ADD_SORTED);
  530. }
  531. }
  532. }
  534. //*************************************
  535. //** LLPanelGroupLandMoney Functions **
  536. //*************************************
  539. //static
  540. LLMap<LLUUID, LLPanelGroupLandMoney*> LLPanelGroupLandMoney::sGroupIDs;
  542. LLPanelGroupLandMoney::LLPanelGroupLandMoney() :
  543. LLPanelGroupTab() 
  544. {
  545. //FIXME - add setGroupID();
  546. mImplementationp = new impl(*this);
  548. //problem what if someone has both the group floater open and the finder
  549. //open to the same group?  Some maps that map group ids to panels
  550. //will then only be working for the last panel for a given group id :(
  552. //FIXME - add to setGroupID()
  553. //LLPanelGroupLandMoney::sGroupIDs.addData(group_id, this);
  554. }
  556. LLPanelGroupLandMoney::~LLPanelGroupLandMoney()
  557. {
  558. delete mImplementationp;
  559. LLPanelGroupLandMoney::sGroupIDs.removeData(mGroupID);
  560. }
  562. void LLPanelGroupLandMoney::activate()
  563. {
  564. if ( !mImplementationp->mBeenActivated )
  565. {
  566. //select the first tab
  567. LLTabContainer* tabp = getChild<LLTabContainer>("group_money_tab_container");
  569. if ( tabp )
  570. {
  571. tabp->selectFirstTab();
  572. mImplementationp->mBeenActivated = true;
  573. }
  575. //fill in the max contribution
  577. //This calculation is unfortunately based on
  578. //the status bar's concept of how much land the user has
  579. //which can change dynamically if the user buys new land, gives
  580. //more land to a group, etc.
  581. //A race condition can occur if we want to update the UI's
  582. //concept of the user's max contribution before the status
  583. //bar has been updated from a change in the user's group contribution.
  585. //Since the max contribution should not change solely on changing
  586. //a user's group contribution, (it would only change through
  587. //purchasing of new land) this code is placed here
  588. //and only updated once to prevent the race condition
  589. //at the price of having stale data.
  590. //We need to have the status bar have observers
  591. //or find better way of distributing up to date land data. - jwolk
  592. S32 max_avail = mImplementationp->getStoredContribution();
  593. if(gStatusBar)
  594. {
  595. max_avail += gStatusBar->getSquareMetersLeft();
  596. }
  597. mImplementationp->setYourMaxContributionTextBox(max_avail);
  598. }
  600. mImplementationp->mMapButtonp->setEnabled(false);
  601. update(GC_ALL);
  602. }
  604. void LLPanelGroupLandMoney::update(LLGroupChange gc)
  605. {
  606. if (gc != GC_ALL) return;  //Don't update if it's the wrong panel!
  608. LLTabContainer* tabp = getChild<LLTabContainer>("group_money_tab_container");
  610. if ( tabp )
  611. {
  612. LLPanel* panelp;
  613. LLGroupMoneyTabEventHandler* eh;
  615. panelp = tabp->getCurrentPanel();
  617. //now pull the event handler associated with that L$ tab
  618. if ( panelp )
  619. {
  620. eh = get_if_there(LLGroupMoneyTabEventHandler::sTabsToHandlers,
  621.   panelp,
  622.   (LLGroupMoneyTabEventHandler*)NULL);
  623. if ( eh ) eh->onClickTab();
  624. }
  625. }
  627. mImplementationp->requestGroupLandInfo();
  628. mImplementationp->setYourContributionTextField(mImplementationp->getStoredContribution());
  629. }
  631. bool LLPanelGroupLandMoney::needsApply(std::string& mesg)
  632. {
  633. return mImplementationp->mNeedsApply;
  634. }
  636. bool LLPanelGroupLandMoney::apply(std::string& mesg)
  637. {
  638. if (!mImplementationp->applyContribution() )
  639. {
  640. mesg = getString("land_contrib_error"); 
  641. return false;
  642. }
  644. mImplementationp->mNeedsApply = false;
  645. notifyObservers();
  647. return true;
  648. }
  650. void LLPanelGroupLandMoney::cancel()
  651. {
  652. //set the contribution back to the "stored value"
  653. mImplementationp->setYourContributionTextField(mImplementationp->getStoredContribution());
  655. mImplementationp->mNeedsApply = false;
  656. notifyObservers();
  657. }
  660. BOOL LLPanelGroupLandMoney::postBuild()
  661. {
  662. /* This power was removed to make group roles simpler
  663. bool has_parcel_view     = gAgent.hasPowerInGroup(mGroupID,
  664.   GP_LAND_VIEW_OWNED);
  665. bool has_accounting_view = gAgent.hasPowerInGroup(mGroupID,
  666.   GP_ACCOUNTING_VIEW);
  667. */
  669. bool can_view = gAgent.isInGroup(mGroupID);
  671. mImplementationp->mGroupOverLimitIconp = 
  672. getChild<LLIconCtrl>("group_over_limit_icon");
  673. mImplementationp->mGroupOverLimitTextp = 
  674. getChild<LLTextBox>("group_over_limit_text");
  676. mImplementationp->mYourContributionEditorp 
  677. = getChild<LLLineEditor>("your_contribution_line_editor");
  678. if ( mImplementationp->mYourContributionEditorp )
  679. {
  680. LLLineEditor* editor = mImplementationp->mYourContributionEditorp;
  682.     editor->setCommitCallback(mImplementationp->contributionCommitCallback, this);
  683. editor->setKeystrokeCallback(mImplementationp->contributionKeystrokeCallback, this);
  684. }
  686. mImplementationp->mMapButtonp = getChild<LLButton>("map_button");
  688. mImplementationp->mGroupParcelsp = 
  689. getChild<LLScrollListCtrl>("group_parcel_list");
  691. if ( mImplementationp->mGroupParcelsp )
  692. {
  693. mImplementationp->mGroupParcelsp->setCommitCallback(boost::bind(&LLPanelGroupLandMoney::onLandSelectionChanged, this));
  694. mImplementationp->mGroupParcelsp->setCommitOnSelectionChange(true);
  695. }
  697. mImplementationp->mCantViewParcelsText = getString("cant_view_group_land_text");
  698. mImplementationp->mCantViewAccountsText = getString("cant_view_group_accounting_text");
  700. if ( mImplementationp->mMapButtonp )
  701. {
  702. mImplementationp->mMapButtonp->setClickedCallback(LLPanelGroupLandMoney::impl::mapCallback, mImplementationp);
  703. }
  705. if ( mImplementationp->mGroupOverLimitTextp )
  706. {
  707. mImplementationp->mGroupOverLimitTextp->setVisible(FALSE);
  708. }
  710. if ( mImplementationp->mGroupOverLimitIconp )
  711. {
  712. mImplementationp->mGroupOverLimitIconp->setVisible(FALSE);
  713. }
  715. if ( !can_view )
  716. {
  717. if ( mImplementationp->mGroupParcelsp )
  718. {
  719. mImplementationp->mGroupParcelsp->setCommentText(
  720. mImplementationp->mCantViewParcelsText);
  721. mImplementationp->mGroupParcelsp->setEnabled(FALSE);
  722. }
  723. }
  727. LLButton* earlierp, *laterp;
  728. LLTextEditor* textp;
  729. LLPanel* panelp;
  731. LLTabContainer* tabcp = getChild<LLTabContainer>("group_money_tab_container");
  733. if ( !can_view )
  734. {
  735. if ( tabcp )
  736. {
  737. S32 i;
  738. S32 tab_count = tabcp->getTabCount();
  740. for (i = tab_count - 1; i >=0; --i)
  741. {
  742. tabcp->enableTabButton(i, false);
  743. }
  744. }
  745. }
  747. std::string loading_text = getString("loading_txt");
  749. //pull out the widgets for the L$ details tab
  750. earlierp = getChild<LLButton>("earlier_details_button", true);
  751. laterp = getChild<LLButton>("later_details_button", true);
  752. textp = getChild<LLTextEditor>("group_money_details_text", true);
  753. panelp = getChild<LLPanel>("group_money_details_tab", true);
  755. if ( !can_view )
  756. {
  757. textp->setText(mImplementationp->mCantViewAccountsText);
  758. }
  759. else
  760. {
  761. mImplementationp->mMoneyDetailsTabEHp = 
  762. new LLGroupMoneyDetailsTabEventHandler(earlierp,
  763.    laterp,
  764.    textp,
  765.    tabcp,
  766.    panelp,
  767.    loading_text);
  768. }
  770. textp = getChild<LLTextEditor>("group_money_planning_text", true);
  771. panelp = getChild<LLPanel>("group_money_planning_tab", true);
  773. if ( !can_view )
  774. {
  775. textp->setText(mImplementationp->mCantViewAccountsText);
  776. }
  777. else
  778. {
  779. //Temporally disabled for DEV-11287.
  780. mImplementationp->mMoneyPlanningTabEHp = 
  781. new LLGroupMoneyPlanningTabEventHandler(textp,
  782. tabcp,
  783. panelp,
  784. loading_text);
  785. }
  787. //pull out the widgets for the L$ sales tab
  788. earlierp = getChild<LLButton>("earlier_sales_button", true);
  789. laterp = getChild<LLButton>("later_sales_button", true);
  790. textp = getChild<LLTextEditor>("group_money_sales_text", true);
  791. panelp = getChild<LLPanel>("group_money_sales_tab", true);
  793. if ( !can_view )
  794. {
  795. textp->setText(mImplementationp->mCantViewAccountsText);
  796. }
  797. else
  798. {
  799. mImplementationp->mMoneySalesTabEHp = 
  800. new LLGroupMoneySalesTabEventHandler(earlierp,
  801.  laterp,
  802.  textp,
  803.  tabcp,
  804.  panelp,
  805.  loading_text);
  806. }
  808. return LLPanelGroupTab::postBuild();
  809. }
  811. void LLPanelGroupLandMoney::onLandSelectionChanged()
  812. {
  813. mImplementationp->mMapButtonp->setEnabled( mImplementationp->mGroupParcelsp->getItemCount() > 0 );
  814. }
  816. BOOL LLPanelGroupLandMoney::isVisibleByAgent(LLAgent* agentp)
  817. {
  818. return mAllowEdit && agentp->isInGroup(mGroupID);
  819. }
  821. void LLPanelGroupLandMoney::processPlacesReply(LLMessageSystem* msg, void**)
  822. {
  823. LLUUID group_id;
  824. msg->getUUID("AgentData", "QueryID", group_id);
  826. LLPanelGroupLandMoney* selfp = sGroupIDs.getIfThere(group_id);
  827. if(!selfp)
  828. {
  829. llinfos << "Group Panel Land L$ " << group_id << " no longer in existence."
  830. << llendl;
  831. return;
  832. }
  834. selfp->mImplementationp->processGroupLand(msg);
  835. }
  838. LLGroupMoneyTabEventHandlerImpl::LLGroupMoneyTabEventHandlerImpl(LLButton* earlier_buttonp,
  839. LLButton* later_buttonp,
  840. LLTextEditor* text_editorp,
  841. LLPanel* tabpanelp,
  842. const std::string& loading_text,
  843. S32 interval_length_days,
  844. S32 max_interval_days)
  845. {
  846. mPanelID.generate();
  848. mIntervalLength = interval_length_days;
  849. mMaxInterval = max_interval_days;
  850. mCurrentInterval = 0;
  852. mTextEditorp = text_editorp;
  853. mEarlierButtonp = earlier_buttonp;
  854. mLaterButtonp = later_buttonp;
  855. mTabPanelp = tabpanelp;
  857. mLoadingText = loading_text;
  858. }
  860. LLGroupMoneyTabEventHandlerImpl::~LLGroupMoneyTabEventHandlerImpl()
  861. {
  862. }
  864. bool LLGroupMoneyTabEventHandlerImpl::getCanClickEarlier()
  865. {
  866. return (mCurrentInterval < mMaxInterval);
  867. }
  869. bool LLGroupMoneyTabEventHandlerImpl::getCanClickLater()
  870. {
  871. return ( mCurrentInterval > 0 );
  872. }
  874. void LLGroupMoneyTabEventHandlerImpl::updateButtons()
  875. {
  876. if ( mEarlierButtonp )
  877. {
  878. mEarlierButtonp->setEnabled(getCanClickEarlier());
  879. }
  880. if ( mLaterButtonp )
  881. {
  882. mLaterButtonp->setEnabled(getCanClickLater());
  883. }
  884. }
  886. //*******************************************
  887. //** LLGroupMoneyTabEventHandler Functions **
  888. //*******************************************
  890. LLMap<LLUUID, LLGroupMoneyTabEventHandler*> LLGroupMoneyTabEventHandler::sInstanceIDs;
  891. std::map<LLPanel*, LLGroupMoneyTabEventHandler*> LLGroupMoneyTabEventHandler::sTabsToHandlers;
  893. LLGroupMoneyTabEventHandler::LLGroupMoneyTabEventHandler(LLButton* earlier_buttonp,
  894.  LLButton* later_buttonp,
  895.  LLTextEditor* text_editorp,
  896.  LLTabContainer* tab_containerp,
  897.  LLPanel* panelp,
  898.  const std::string& loading_text,
  899.  S32 interval_length_days,
  900.  S32 max_interval_days)
  901. {
  902. mImplementationp = new LLGroupMoneyTabEventHandlerImpl(earlier_buttonp,
  903. later_buttonp,
  904. text_editorp,
  905. panelp,
  906. loading_text,
  907. interval_length_days,
  908. max_interval_days);
  910. if ( earlier_buttonp )
  911. {
  912. earlier_buttonp->setClickedCallback(clickEarlierCallback, this);
  913. }
  915. if ( later_buttonp )
  916. {
  917. later_buttonp->setClickedCallback(clickLaterCallback, this);
  918. }
  920. mImplementationp->updateButtons();
  922. if ( tab_containerp && panelp )
  923. {
  924. tab_containerp->setCommitCallback(boost::bind(&LLGroupMoneyTabEventHandler::onClickTab, this));
  925. }
  927. sInstanceIDs.addData(mImplementationp->mPanelID, this);
  928. sTabsToHandlers[panelp] = this;
  929. }
  931. LLGroupMoneyTabEventHandler::~LLGroupMoneyTabEventHandler()
  932. {
  933. sInstanceIDs.removeData(mImplementationp->mPanelID);
  934. sTabsToHandlers.erase(mImplementationp->mTabPanelp);
  936. delete mImplementationp;
  937. }
  940. void LLGroupMoneyTabEventHandler::onClickTab()
  941. {
  942. requestData(gMessageSystem);
  943. }
  945. void LLGroupMoneyTabEventHandler::requestData(LLMessageSystem* msg)
  946. {
  947. //do nothing
  948. }
  950. void LLGroupMoneyTabEventHandler::processReply(LLMessageSystem* msg, void** data)
  951. {
  952. //do nothing
  953. }
  955. void LLGroupMoneyTabEventHandler::onClickEarlier()
  956. {
  957. if ( mImplementationp->mTextEditorp) 
  958. {
  959. mImplementationp->mTextEditorp->setText(mImplementationp->mLoadingText);
  960. }
  961. mImplementationp->mCurrentInterval++;
  963. mImplementationp->updateButtons();
  965. requestData(gMessageSystem);
  966. }
  968. void LLGroupMoneyTabEventHandler::onClickLater()
  969. {
  970. if ( mImplementationp->mTextEditorp )
  971. {
  972. mImplementationp->mTextEditorp->setText(mImplementationp->mLoadingText);
  973. }
  974. mImplementationp->mCurrentInterval--;
  976. mImplementationp->updateButtons();
  978. requestData(gMessageSystem);
  979. }
  981. //static
  982. void LLGroupMoneyTabEventHandler::clickEarlierCallback(void* data)
  983. {
  984. LLGroupMoneyTabEventHandler* selfp = (LLGroupMoneyTabEventHandler*) data;
  986. if ( selfp ) selfp->onClickEarlier();
  987. }
  989. //static
  990. void LLGroupMoneyTabEventHandler::clickLaterCallback(void* data)
  991. {
  992. LLGroupMoneyTabEventHandler* selfp = (LLGroupMoneyTabEventHandler*) data;
  993. if ( selfp ) selfp->onClickLater();
  994. }
  996. //**************************************************
  997. //** LLGroupMoneyDetailsTabEventHandler Functions **
  998. //**************************************************
  1000. LLGroupMoneyDetailsTabEventHandler::LLGroupMoneyDetailsTabEventHandler(LLButton* earlier_buttonp,
  1001.    LLButton* later_buttonp,
  1002.    LLTextEditor* text_editorp,
  1003.    LLTabContainer* tab_containerp,
  1004.    LLPanel* panelp,
  1005.    const std::string& loading_text)
  1006. : LLGroupMoneyTabEventHandler(earlier_buttonp,
  1007.   later_buttonp,
  1008.   text_editorp,
  1009.   tab_containerp,
  1010.   panelp,
  1011.   loading_text,
  1012.   SUMMARY_INTERVAL,
  1013.   SUMMARY_MAX)
  1014. {
  1015. }
  1017. LLGroupMoneyDetailsTabEventHandler::~LLGroupMoneyDetailsTabEventHandler()
  1018. {
  1019. }
  1021. void LLGroupMoneyDetailsTabEventHandler::requestData(LLMessageSystem* msg)
  1022. {
  1023. msg->newMessageFast(_PREHASH_GroupAccountDetailsRequest);
  1024. msg->nextBlockFast(_PREHASH_AgentData);
  1025. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1026. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  1027. msg->addUUIDFast(_PREHASH_GroupID,  mImplementationp->getGroupID() );
  1028. msg->nextBlockFast(_PREHASH_MoneyData);
  1029. msg->addUUIDFast(_PREHASH_RequestID, mImplementationp->mPanelID );
  1030. msg->addS32Fast(_PREHASH_IntervalDays, mImplementationp->mIntervalLength );
  1031. msg->addS32Fast(_PREHASH_CurrentInterval, mImplementationp->mCurrentInterval);
  1033. gAgent.sendReliableMessage();
  1035. if ( mImplementationp->mTextEditorp )
  1036. {
  1037. mImplementationp->mTextEditorp->setText(mImplementationp->mLoadingText);
  1038. }
  1040. LLGroupMoneyTabEventHandler::requestData(msg);
  1041. }
  1043. void LLGroupMoneyDetailsTabEventHandler::processReply(LLMessageSystem* msg, 
  1044.   void** data)
  1045. {
  1046. LLUUID group_id;
  1047. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_GroupID, group_id );
  1048. if (mImplementationp->getGroupID() != group_id) 
  1049. {
  1050. llwarns << "Group Account details not for this group!" << llendl;
  1051. return;
  1052. }
  1054. std::string start_date;
  1055. S32 interval_days;
  1056. S32 current_interval;
  1058. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_IntervalDays, interval_days );
  1059. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_CurrentInterval, current_interval );
  1060. msg->getStringFast(_PREHASH_MoneyData, _PREHASH_StartDate, start_date);
  1062. if ( interval_days != mImplementationp->mIntervalLength || 
  1063.  current_interval != mImplementationp->mCurrentInterval )
  1064. {
  1065. llinfos << "Out of date details packet " << interval_days << " " 
  1066. << current_interval << llendl;
  1067. return;
  1068. }
  1070. std::string text = start_date;
  1071. text.append("nn");
  1073. S32 total_amount = 0;
  1074. S32 transactions = msg->getNumberOfBlocksFast(_PREHASH_HistoryData);
  1075. for(S32 i = 0; i < transactions; i++)
  1076. {
  1077. S32 amount = 0;
  1078. std::string desc;
  1080. msg->getStringFast(_PREHASH_HistoryData, _PREHASH_Description, desc, i );
  1081. msg->getS32Fast(_PREHASH_HistoryData, _PREHASH_Amount, amount, i);
  1083. if (amount != 0)
  1084. {
  1085. text.append(llformat("%-24s %6dn", desc.c_str(), amount));
  1086. }
  1087. else
  1088. {
  1089. // skip it
  1090. }
  1092. total_amount += amount;
  1093. }
  1095. text.append(1, 'n');
  1097. text.append(llformat("%-24s %6dn", LLTrans::getString("GroupMoneyTotal").c_str(), total_amount));
  1099. if ( mImplementationp->mTextEditorp )
  1100. {
  1101. mImplementationp->mTextEditorp->setText(text);
  1102. }
  1103. }
  1105. //static
  1106. void LLPanelGroupLandMoney::processGroupAccountDetailsReply(LLMessageSystem* msg, 
  1107. void** data)
  1108. {
  1109. LLUUID agent_id;
  1110. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  1111. if (gAgent.getID() != agent_id)
  1112. {
  1113. llwarns << "Got group L$ history reply for another agent!" << llendl;
  1114. return;
  1115. }
  1117. LLUUID request_id;
  1118. msg->getUUIDFast(_PREHASH_MoneyData, _PREHASH_RequestID, request_id );
  1119. LLGroupMoneyTabEventHandler* selfp = LLGroupMoneyTabEventHandler::sInstanceIDs.getIfThere(request_id);
  1120. if (!selfp)
  1121. {
  1122. llwarns << "GroupAccountDetails recieved for non-existent group panel." << llendl;
  1123. return;
  1124. }
  1126. selfp->processReply(msg, data);
  1127. }
  1129. //************************************************
  1130. //** LLGroupMoneySalesTabEventHandler Functions **
  1131. //************************************************
  1133. LLGroupMoneySalesTabEventHandler::LLGroupMoneySalesTabEventHandler(LLButton* earlier_buttonp,
  1134.    LLButton* later_buttonp,
  1135.    LLTextEditor* text_editorp,
  1136.    LLTabContainer* tab_containerp,
  1137.    LLPanel* panelp,
  1138.    const std::string& loading_text)
  1139. : LLGroupMoneyTabEventHandler(earlier_buttonp,
  1140.   later_buttonp,
  1141.   text_editorp,
  1142.   tab_containerp,
  1143.   panelp,
  1144.   loading_text,
  1145.   SUMMARY_INTERVAL,
  1146.   SUMMARY_MAX)
  1147. {
  1148. }
  1150. LLGroupMoneySalesTabEventHandler::~LLGroupMoneySalesTabEventHandler()
  1151. {
  1152. }
  1154. void LLGroupMoneySalesTabEventHandler::requestData(LLMessageSystem* msg)
  1155. {
  1156. msg->newMessageFast(_PREHASH_GroupAccountTransactionsRequest);
  1157. msg->nextBlockFast(_PREHASH_AgentData);
  1158. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1159. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  1160. msg->addUUIDFast(_PREHASH_GroupID, mImplementationp->getGroupID() );
  1161. msg->nextBlockFast(_PREHASH_MoneyData);
  1162. msg->addUUIDFast(_PREHASH_RequestID, mImplementationp->mPanelID );
  1163. msg->addS32Fast(_PREHASH_IntervalDays, mImplementationp->mIntervalLength );
  1164. msg->addS32Fast(_PREHASH_CurrentInterval, mImplementationp->mCurrentInterval);
  1166. gAgent.sendReliableMessage();
  1168. if ( mImplementationp->mTextEditorp )
  1169. {
  1170. mImplementationp->mTextEditorp->setText(mImplementationp->mLoadingText);
  1171. }
  1173. LLGroupMoneyTabEventHandler::requestData(msg);
  1174. }
  1176. void LLGroupMoneySalesTabEventHandler::processReply(LLMessageSystem* msg, 
  1177. void** data)
  1178. {
  1179. LLUUID group_id;
  1180. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_GroupID, group_id );
  1181. if (mImplementationp->getGroupID() != group_id) 
  1182. {
  1183. llwarns << "Group Account Transactions not for this group!" << llendl;
  1184. return;
  1185. }
  1187. std::string text = mImplementationp->mTextEditorp->getText();
  1189. std::string start_date;
  1190. S32 interval_days;
  1191. S32 current_interval;
  1193. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_IntervalDays, interval_days );
  1194. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_CurrentInterval, current_interval );
  1195. msg->getStringFast(_PREHASH_MoneyData, _PREHASH_StartDate, start_date);
  1197. if (interval_days != mImplementationp->mIntervalLength ||
  1198.     current_interval != mImplementationp->mCurrentInterval)
  1199. {
  1200. llinfos << "Out of date details packet " << interval_days << " " 
  1201. << current_interval << llendl;
  1202. return;
  1203. }
  1205. // If this is the first packet, clear the text, don't append.
  1206. // Start with the date.
  1207. if (text == mImplementationp->mLoadingText)
  1208. {
  1209. text = start_date + "nn";
  1210. }
  1212. S32 transactions = msg->getNumberOfBlocksFast(_PREHASH_HistoryData);
  1213. if (transactions == 0)
  1214. {
  1215. text.append(LLTrans::getString("none_text")); 
  1216. }
  1217. else
  1218. {
  1219. for(S32 i = 0; i < transactions; i++)
  1220. {
  1221. std::string time;
  1222. S32 type = 0;
  1223. S32 amount = 0;
  1224. std::string user;
  1225. std::string item;
  1227. msg->getStringFast(_PREHASH_HistoryData, _PREHASH_Time, time, i);
  1228. msg->getStringFast(_PREHASH_HistoryData, _PREHASH_User, user, i );
  1229. msg->getS32Fast(_PREHASH_HistoryData, _PREHASH_Type, type, i);
  1230. msg->getStringFast(_PREHASH_HistoryData, _PREHASH_Item, item, i );
  1231. msg->getS32Fast(_PREHASH_HistoryData, _PREHASH_Amount, amount, i);
  1233. if (amount != 0)
  1234. {
  1235. std::string verb;
  1237. switch(type)
  1238. {
  1239. case TRANS_OBJECT_SALE:
  1240. verb = LLTrans::getString("GroupMoneyBought").c_str();
  1241. break;
  1242. case TRANS_GIFT:
  1243. verb = LLTrans::getString("GroupMoneyPaidYou").c_str();
  1244. break;
  1245. case TRANS_PAY_OBJECT:
  1246. verb = LLTrans::getString("GroupMoneyPaidInto").c_str();
  1247. break;
  1248. case TRANS_LAND_PASS_SALE:
  1249. verb = LLTrans::getString("GroupMoneyBoughtPassTo").c_str();
  1250. break;
  1251. case TRANS_EVENT_FEE:
  1252. verb = LLTrans::getString("GroupMoneyPaidFeeForEvent").c_str();
  1253. break;
  1254. case TRANS_EVENT_PRIZE:
  1255. verb = LLTrans::getString("GroupMoneyPaidPrizeForEvent").c_str();
  1256. break;
  1257. default:
  1258. verb = "";
  1259. break;
  1260. }
  1262. std::string line = llformat("%s %6d - %s %s %sn", time.c_str(), amount, user.c_str(), verb.c_str(), item.c_str());
  1263. text.append(line);
  1264. }
  1265. }
  1266. }
  1268. if ( mImplementationp->mTextEditorp)
  1269. {
  1270. mImplementationp->mTextEditorp->setText(text);
  1271. }
  1272. }
  1274. //static
  1275. void LLPanelGroupLandMoney::processGroupAccountTransactionsReply(LLMessageSystem* msg, 
  1276.  void** data)
  1277. {
  1278. LLUUID agent_id;
  1279. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  1280. if (gAgent.getID() != agent_id)
  1281. {
  1282. llwarns << "Got group L$ history reply for another agent!" << llendl;
  1283. return;
  1284. }
  1286. LLUUID request_id;
  1287. msg->getUUIDFast(_PREHASH_MoneyData, _PREHASH_RequestID, request_id );
  1289. LLGroupMoneyTabEventHandler* self;
  1291. self = LLGroupMoneyTabEventHandler::sInstanceIDs.getIfThere(request_id);
  1292. if (!self)
  1293. {
  1294. llwarns << "GroupAccountTransactions recieved for non-existent group panel." << llendl;
  1295. return;
  1296. }
  1298. self->processReply(msg, data);
  1299. }
  1301. //***************************************************
  1302. //** LLGroupMoneyPlanningTabEventHandler Functions **
  1303. //***************************************************
  1305. LLGroupMoneyPlanningTabEventHandler::LLGroupMoneyPlanningTabEventHandler(LLTextEditor* text_editorp,
  1306.  LLTabContainer* tab_containerp,
  1307.  LLPanel* panelp,
  1308.  const std::string& loading_text)
  1309. : LLGroupMoneyTabEventHandler(NULL,
  1310.   NULL,
  1311.   text_editorp,
  1312.   tab_containerp,
  1313.   panelp,
  1314.   loading_text,
  1315.   SUMMARY_INTERVAL,
  1316.   SUMMARY_MAX)
  1317. {
  1318. }
  1320. LLGroupMoneyPlanningTabEventHandler::~LLGroupMoneyPlanningTabEventHandler()
  1321. {
  1322. }
  1324. void LLGroupMoneyPlanningTabEventHandler::requestData(LLMessageSystem* msg)
  1325. {
  1326. msg->newMessageFast(_PREHASH_GroupAccountSummaryRequest);
  1327. msg->nextBlockFast(_PREHASH_AgentData);
  1328. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1329. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
  1330. msg->addUUIDFast(_PREHASH_GroupID, mImplementationp->getGroupID() );
  1331. msg->nextBlockFast(_PREHASH_MoneyData);
  1332. msg->addUUIDFast(_PREHASH_RequestID, mImplementationp->mPanelID );
  1333. msg->addS32Fast(_PREHASH_IntervalDays, mImplementationp->mIntervalLength);
  1334. msg->addS32Fast(_PREHASH_CurrentInterval, 0); //planning has 0 interval
  1336. gAgent.sendReliableMessage();
  1338. if ( mImplementationp->mTextEditorp )
  1339. {
  1340. mImplementationp->mTextEditorp->setText(mImplementationp->mLoadingText);
  1341. }
  1343. LLGroupMoneyTabEventHandler::requestData(msg);
  1344. }
  1346. void LLGroupMoneyPlanningTabEventHandler::processReply(LLMessageSystem* msg, 
  1347. void** data)
  1348. {
  1349. LLUUID group_id;
  1350. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_GroupID, group_id );
  1351. if (mImplementationp->getGroupID() != group_id) 
  1352. {
  1353. llwarns << "Group Account Summary received not for this group!" << llendl;
  1354. return;
  1355. }
  1357. std::string text;
  1359. std::string start_date;
  1360. std::string last_stipend_date;
  1361. std::string next_stipend_date;
  1362. S32 interval_days;
  1363. S32 current_interval;
  1364. S32 balance;
  1365. S32 total_credits;
  1366. S32 total_debits;
  1367. S32 cur_object_tax;
  1368. S32 cur_light_tax;
  1369. S32 cur_land_tax;
  1370. S32 cur_group_tax;
  1371. S32 cur_parcel_dir_fee;
  1372. S32 cur_total_tax;
  1373. S32 proj_object_tax;
  1374. S32 proj_light_tax;
  1375. S32 proj_land_tax;
  1376. S32 proj_group_tax;
  1377. S32 proj_parcel_dir_fee;
  1378. S32 proj_total_tax;
  1379. S32 non_exempt_members;
  1381. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_IntervalDays, interval_days );
  1382. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_CurrentInterval, current_interval );
  1383. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_Balance, balance );
  1384. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_TotalCredits, total_credits );
  1385. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_TotalDebits, total_debits );
  1386. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_ObjectTaxCurrent, cur_object_tax );
  1387. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_LightTaxCurrent, cur_light_tax );
  1388. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_LandTaxCurrent, cur_land_tax );
  1389. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_GroupTaxCurrent, cur_group_tax );
  1390. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_ParcelDirFeeCurrent, cur_parcel_dir_fee );
  1391. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_ObjectTaxEstimate, proj_object_tax );
  1392. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_LightTaxEstimate, proj_light_tax );
  1393. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_LandTaxEstimate, proj_land_tax );
  1394. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_GroupTaxEstimate, proj_group_tax );
  1395. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_ParcelDirFeeEstimate, proj_parcel_dir_fee );
  1396. msg->getS32Fast(_PREHASH_MoneyData, _PREHASH_NonExemptMembers, non_exempt_members );
  1398. msg->getStringFast(_PREHASH_MoneyData, _PREHASH_StartDate, start_date);
  1399. msg->getStringFast(_PREHASH_MoneyData, _PREHASH_LastTaxDate, last_stipend_date);
  1400. msg->getStringFast(_PREHASH_MoneyData, _PREHASH_TaxDate, next_stipend_date);
  1402. cur_total_tax = cur_object_tax + cur_light_tax + cur_land_tax + cur_group_tax +  cur_parcel_dir_fee;
  1403. proj_total_tax = proj_object_tax + proj_light_tax + proj_land_tax + proj_group_tax + proj_parcel_dir_fee;
  1405. if (interval_days != mImplementationp->mIntervalLength || 
  1406. current_interval != mImplementationp->mCurrentInterval)
  1407. {
  1408. llinfos << "Out of date summary packet " << interval_days << " " 
  1409. << current_interval << llendl;
  1410. return;
  1411. }
  1413. text.append(LLTrans::getString("SummaryForTheWeek"));
  1414. text.append(start_date);
  1416. if (current_interval == 0)
  1417. {
  1418. text.append(LLTrans::getString("NextStipendDay"));
  1419. text.append(next_stipend_date);
  1420. text.append("nn");
  1421. text.append(llformat("%-24sL$%6dn", LLTrans::getString("GroupMoneyBalance").c_str(), balance ));
  1422. text.append(1, 'n');
  1423. }
  1425. // [DEV-29503] Hide the individual info since
  1426. // non_exempt_member here is a wrong choice to calculate individual shares.
  1427. //  text.append( LLTrans::getString("GroupIndividualShare"));
  1428. //  text.append(llformat( "%-24s %6d      %6d n", LLTrans::getString("GroupMoneyCredits").c_str(), total_credits, (S32)floor((F32)total_credits/(F32)non_exempt_members)));
  1429. //  text.append(llformat( "%-24s %6d      %6d n", LLTrans::getString("GroupMoneyDebits").c_str(), total_debits, (S32)floor((F32)total_debits/(F32)non_exempt_members)));
  1430. //  text.append(llformat( "%-24s %6d      %6d n", LLTrans::getString("GroupMoneyTotal").c_str(), total_credits + total_debits,  (S32)floor((F32)(total_credits + total_debits)/(F32)non_exempt_members)));
  1432. text.append( "                      Groupn");
  1433. text.append(llformat( "%-24s %6dn", "Credits", total_credits));
  1434. text.append(llformat( "%-24s %6dn", "Debits", total_debits));
  1435. text.append(llformat( "%-24s %6dn", "Total", total_credits + total_debits));
  1437. if ( mImplementationp->mTextEditorp )
  1438. {
  1439. mImplementationp->mTextEditorp->setText(text);
  1440. }
  1441. }
  1443. //static
  1444. void LLPanelGroupLandMoney::processGroupAccountSummaryReply(LLMessageSystem* msg, 
  1445. void** data)
  1446. {
  1447. LLUUID agent_id;
  1448. msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
  1449. if (gAgent.getID() != agent_id)
  1450. {
  1451. llwarns << "Got group L$ history reply for another agent!" << llendl;
  1452. return;
  1453. }
  1455. LLUUID request_id;
  1456. msg->getUUIDFast(_PREHASH_MoneyData, _PREHASH_RequestID, request_id );
  1458. LLGroupMoneyTabEventHandler* self;
  1460. self = LLGroupMoneyTabEventHandler::sInstanceIDs.getIfThere(request_id);
  1461. if (!self)
  1462. {
  1463. llwarns << "GroupAccountSummary recieved for non-existent group L$ planning tab." << llendl;
  1464. return;
  1465. }
  1467. self->processReply(msg, data);
  1468. }
  1470. void LLPanelGroupLandMoney::setGroupID(const LLUUID& id)
  1471. {
  1472. LLPanelGroupLandMoney::sGroupIDs.removeData(mGroupID);
  1473. LLPanelGroupTab::setGroupID(id);
  1474. LLPanelGroupLandMoney::sGroupIDs.addData(mGroupID, this);
  1477. bool can_view = gAgent.isInGroup(mGroupID);
  1479. mImplementationp->mGroupOverLimitIconp = 
  1480. getChild<LLIconCtrl>("group_over_limit_icon");
  1481. mImplementationp->mGroupOverLimitTextp = 
  1482. getChild<LLTextBox>("group_over_limit_text");
  1484. mImplementationp->mYourContributionEditorp 
  1485. = getChild<LLLineEditor>("your_contribution_line_editor");
  1486. if ( mImplementationp->mYourContributionEditorp )
  1487. {
  1488. LLLineEditor* editor = mImplementationp->mYourContributionEditorp;
  1490.     editor->setCommitCallback(mImplementationp->contributionCommitCallback, this);
  1491. editor->setKeystrokeCallback(mImplementationp->contributionKeystrokeCallback, this);
  1492. }
  1494. mImplementationp->mMapButtonp = getChild<LLButton>("map_button");
  1496. mImplementationp->mGroupParcelsp = 
  1497. getChild<LLScrollListCtrl>("group_parcel_list");
  1499. if ( mImplementationp->mGroupParcelsp )
  1500. {
  1501. mImplementationp->mGroupParcelsp->setCommitCallback(boost::bind(&LLPanelGroupLandMoney::onLandSelectionChanged, this));
  1502. mImplementationp->mGroupParcelsp->setCommitOnSelectionChange(true);
  1503. }
  1505. mImplementationp->mCantViewParcelsText = getString("cant_view_group_land_text");
  1506. mImplementationp->mCantViewAccountsText = getString("cant_view_group_accounting_text");
  1508. if ( mImplementationp->mMapButtonp )
  1509. {
  1510. mImplementationp->mMapButtonp->setClickedCallback(LLPanelGroupLandMoney::impl::mapCallback, mImplementationp);
  1511. }
  1513. if ( mImplementationp->mGroupOverLimitTextp )
  1514. {
  1515. mImplementationp->mGroupOverLimitTextp->setVisible(FALSE);
  1516. }
  1518. if ( mImplementationp->mGroupOverLimitIconp )
  1519. {
  1520. mImplementationp->mGroupOverLimitIconp->setVisible(FALSE);
  1521. }
  1523. if ( mImplementationp->mGroupParcelsp )
  1524. {
  1525. mImplementationp->mGroupParcelsp->setEnabled(can_view);
  1526. }
  1528. if ( !can_view && mImplementationp->mGroupParcelsp )
  1529. {
  1530. mImplementationp->mGroupParcelsp->setEnabled(FALSE);
  1531. }
  1534. LLButton* earlierp, *laterp;
  1535. LLTextEditor* textp;
  1536. LLPanel* panelp;
  1538. LLTabContainer* tabcp = getChild<LLTabContainer>("group_money_tab_container");
  1540. if ( tabcp )
  1541. {
  1542. S32 i;
  1543. S32 tab_count = tabcp->getTabCount();
  1545. for (i = tab_count - 1; i >=0; --i)
  1546. {
  1547. tabcp->enableTabButton(i, can_view );
  1548. }
  1549. }
  1551. std::string loading_text = getString("loading_txt");
  1553. //pull out the widgets for the L$ details tab
  1554. earlierp = getChild<LLButton>("earlier_details_button", true);
  1555. laterp = getChild<LLButton>("later_details_button", true);
  1556. textp = getChild<LLTextEditor>("group_money_details_text", true);
  1557. panelp = getChild<LLPanel>("group_money_details_tab", true);
  1559. if ( !can_view )
  1560. {
  1561. textp->setText(mImplementationp->mCantViewAccountsText);
  1562. }
  1563. else
  1564. {
  1565. if(mImplementationp->mMoneyDetailsTabEHp == 0)
  1566. mImplementationp->mMoneyDetailsTabEHp = new LLGroupMoneyDetailsTabEventHandler(earlierp,laterp,textp,tabcp,panelp,loading_text);
  1567. mImplementationp->mMoneyDetailsTabEHp->setGroupID(mGroupID);
  1568. }
  1570. textp = getChild<LLTextEditor>("group_money_planning_text", true);
  1573. if ( !can_view )
  1574. {
  1575. textp->setText(mImplementationp->mCantViewAccountsText);
  1576. }
  1577. else
  1578. {
  1579. panelp = getChild<LLPanel>("group_money_planning_tab", true);
  1580. if(mImplementationp->mMoneyPlanningTabEHp == 0)
  1581. mImplementationp->mMoneyPlanningTabEHp = new LLGroupMoneyPlanningTabEventHandler(textp,tabcp,panelp,loading_text);
  1582. mImplementationp->mMoneyPlanningTabEHp->setGroupID(mGroupID);
  1583. }
  1585. //pull out the widgets for the L$ sales tab
  1586. textp = getChild<LLTextEditor>("group_money_sales_text", true);
  1589. if ( !can_view )
  1590. {
  1591. textp->setText(mImplementationp->mCantViewAccountsText);
  1592. }
  1593. else
  1594. {
  1595. earlierp = getChild<LLButton>("earlier_sales_button", true);
  1596. laterp = getChild<LLButton>("later_sales_button", true);
  1597. panelp = getChild<LLPanel>("group_money_sales_tab", true);
  1598. if(mImplementationp->mMoneySalesTabEHp == NULL) 
  1599. mImplementationp->mMoneySalesTabEHp = new LLGroupMoneySalesTabEventHandler(earlierp,laterp,textp,tabcp,panelp,loading_text);
  1600. mImplementationp->mMoneySalesTabEHp->setGroupID(mGroupID);
  1601. }
  1603. activate();
  1604. }