/** * @file llcurrencyuimanager.cpp * @brief LLCurrencyUIManager class implementation * * $LicenseInfo:firstyear=2006&license=viewergpl$ * * Copyright (c) 2006-2009, Linden Research, Inc. * * Second Life Viewer Source Code * The source code in this file ("Source Code") is provided by Linden Lab * to you under the terms of the GNU General Public License, version 2.0 * ("GPL"), unless you have obtained a separate licensing agreement * ("Other License"), formally executed by you and Linden Lab. Terms of * the GPL can be found in doc/GPL-license.txt in this distribution, or * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 * * There are special exceptions to the terms and conditions of the GPL as * it is applied to this Source Code. View the full text of the exception * in the file doc/FLOSS-exception.txt in this software distribution, or * online at * http://secondlifegrid.net/programs/open_source/licensing/flossexception * * By copying, modifying or distributing this software, you acknowledge * that you have read and understood your obligations described above, * and agree to abide by those obligations. * * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, * COMPLETENESS OR PERFORMANCE. * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "lluictrlfactory.h" #include "lltextbox.h" #include "lllineeditor.h" #include "llviewercontrol.h" #include "llversioninfo.h" #include "llcurrencyuimanager.h" // viewer includes #include "llagent.h" #include "llconfirmationmanager.h" #include "llframetimer.h" #include "lllineeditor.h" #include "llviewchildren.h" #include "llxmlrpctransaction.h" #include "llviewernetwork.h" #include "llpanel.h" const F64 CURRENCY_ESTIMATE_FREQUENCY = 2.0; // how long of a pause in typing a currency buy amount before an // esimate is fetched from the server class LLCurrencyUIManager::Impl { public: Impl(LLPanel& dialog); virtual ~Impl(); LLPanel& mPanel; bool mHidden; bool mError; std::string mErrorMessage; std::string mErrorURI; std::string mZeroMessage; // user's choices S32 mUserCurrencyBuy; bool mUserEnteredCurrencyBuy; // from website // pre-viewer 2.0, the server returned estimates as an // integer US cents value, e.g., "1000" for $10.00 // post-viewer 2.0, the server may also return estimates // as a string with currency embedded, e.g., "10.00 Euros" bool mUSDCurrencyEstimated; S32 mUSDCurrencyEstimatedCost; bool mLocalCurrencyEstimated; std::string mLocalCurrencyEstimatedCost; bool mSupportsInternationalBilling; std::string mSiteConfirm; bool mBought; enum TransactionType { TransactionNone, TransactionCurrency, TransactionBuy }; TransactionType mTransactionType; LLXMLRPCTransaction* mTransaction; bool mCurrencyChanged; LLFrameTimer mCurrencyKeyTimer; void updateCurrencyInfo(); void finishCurrencyInfo(); void startCurrencyBuy(const std::string& password); void finishCurrencyBuy(); void clearEstimate(); bool hasEstimate() const; std::string getLocalEstimate() const; void startTransaction(TransactionType type, const char* method, LLXMLRPCValue params); bool checkTransaction(); // return true if update needed void setError(const std::string& message, const std::string& uri); void clearError(); bool considerUpdateCurrency(); // return true if update needed void currencyKey(S32); static void onCurrencyKey(LLLineEditor* caller, void* data); void prepare(); void updateUI(); }; // is potentially not fully constructed. LLCurrencyUIManager::Impl::Impl(LLPanel& dialog) : mPanel(dialog), mHidden(false), mError(false), mUserCurrencyBuy(2000), // note, this is a default, real value set in llfloaterbuycurrency.cpp mUserEnteredCurrencyBuy(false), mSupportsInternationalBilling(false), mBought(false), mTransactionType(TransactionNone), mTransaction(0), mCurrencyChanged(false) { clearEstimate(); } LLCurrencyUIManager::Impl::~Impl() { delete mTransaction; } void LLCurrencyUIManager::Impl::updateCurrencyInfo() { clearEstimate(); mBought = false; mCurrencyChanged = false; if (mUserCurrencyBuy == 0) { mLocalCurrencyEstimated = true; return; } LLXMLRPCValue keywordArgs = LLXMLRPCValue::createStruct(); keywordArgs.appendString("agentId", gAgent.getID().asString()); keywordArgs.appendString( "secureSessionId", gAgent.getSecureSessionID().asString()); keywordArgs.appendInt("currencyBuy", mUserCurrencyBuy); keywordArgs.appendString("viewerChannel", gSavedSettings.getString("VersionChannelName")); keywordArgs.appendInt("viewerMajorVersion", LLVersionInfo::getMajor()); keywordArgs.appendInt("viewerMinorVersion", LLVersionInfo::getMinor()); keywordArgs.appendInt("viewerPatchVersion", LLVersionInfo::getPatch()); keywordArgs.appendInt("viewerBuildVersion", LLVersionInfo::getBuild()); LLXMLRPCValue params = LLXMLRPCValue::createArray(); params.append(keywordArgs); startTransaction(TransactionCurrency, "getCurrencyQuote", params); } void LLCurrencyUIManager::Impl::finishCurrencyInfo() { LLXMLRPCValue result = mTransaction->responseValue(); bool success = result["success"].asBool(); if (!success) { setError( result["errorMessage"].asString(), result["errorURI"].asString() ); return; } LLXMLRPCValue currency = result["currency"]; // old XML-RPC server: estimatedCost = value in US cents mUSDCurrencyEstimated = currency["estimatedCost"].isValid(); if (mUSDCurrencyEstimated) { mUSDCurrencyEstimatedCost = currency["estimatedCost"].asInt(); } // newer XML-RPC server: estimatedLocalCost = local currency string mLocalCurrencyEstimated = currency["estimatedLocalCost"].isValid(); if (mLocalCurrencyEstimated) { mLocalCurrencyEstimatedCost = currency["estimatedLocalCost"].asString(); mSupportsInternationalBilling = true; } S32 newCurrencyBuy = currency["currencyBuy"].asInt(); if (newCurrencyBuy != mUserCurrencyBuy) { mUserCurrencyBuy = newCurrencyBuy; mUserEnteredCurrencyBuy = false; } mSiteConfirm = result["confirm"].asString(); } void LLCurrencyUIManager::Impl::startCurrencyBuy(const std::string& password) { LLXMLRPCValue keywordArgs = LLXMLRPCValue::createStruct(); keywordArgs.appendString("agentId", gAgent.getID().asString()); keywordArgs.appendString( "secureSessionId", gAgent.getSecureSessionID().asString()); keywordArgs.appendInt("currencyBuy", mUserCurrencyBuy); if (mUSDCurrencyEstimated) { keywordArgs.appendInt("estimatedCost", mUSDCurrencyEstimatedCost); } if (mLocalCurrencyEstimated) { keywordArgs.appendString("estimatedLocalCost", mLocalCurrencyEstimatedCost); } keywordArgs.appendString("confirm", mSiteConfirm); if (!password.empty()) { keywordArgs.appendString("password", password); } keywordArgs.appendString("viewerChannel", gSavedSettings.getString("VersionChannelName")); keywordArgs.appendInt("viewerMajorVersion", LLVersionInfo::getMajor()); keywordArgs.appendInt("viewerMinorVersion", LLVersionInfo::getMinor()); keywordArgs.appendInt("viewerPatchVersion", LLVersionInfo::getPatch()); keywordArgs.appendInt("viewerBuildVersion", LLVersionInfo::getBuild()); LLXMLRPCValue params = LLXMLRPCValue::createArray(); params.append(keywordArgs); startTransaction(TransactionBuy, "buyCurrency", params); clearEstimate(); mCurrencyChanged = false; } void LLCurrencyUIManager::Impl::finishCurrencyBuy() { LLXMLRPCValue result = mTransaction->responseValue(); bool success = result["success"].asBool(); if (!success) { setError( result["errorMessage"].asString(), result["errorURI"].asString() ); } else { mUserCurrencyBuy = 0; mUserEnteredCurrencyBuy = false; mBought = true; } } void LLCurrencyUIManager::Impl::startTransaction(TransactionType type, const char* method, LLXMLRPCValue params) { static std::string transactionURI; if (transactionURI.empty()) { transactionURI = LLViewerLogin::getInstance()->getHelperURI() + "currency.php"; } delete mTransaction; mTransactionType = type; mTransaction = new LLXMLRPCTransaction( transactionURI, method, params, false /* don't use gzip */ ); clearError(); } void LLCurrencyUIManager::Impl::clearEstimate() { mUSDCurrencyEstimated = false; mUSDCurrencyEstimatedCost = 0; mLocalCurrencyEstimated = false; mLocalCurrencyEstimatedCost = "0"; } bool LLCurrencyUIManager::Impl::hasEstimate() const { return (mUSDCurrencyEstimated || mLocalCurrencyEstimated); } std::string LLCurrencyUIManager::Impl::getLocalEstimate() const { if (mLocalCurrencyEstimated) { // we have the new-style local currency string return mLocalCurrencyEstimatedCost; } if (mUSDCurrencyEstimated) { // we have the old-style USD-specific value return "US$ " + llformat("%#.2f", mUSDCurrencyEstimatedCost / 100.0); } return ""; } bool LLCurrencyUIManager::Impl::checkTransaction() { if (!mTransaction) { return false; } if (!mTransaction->process()) { return false; } if (mTransaction->status(NULL) != LLXMLRPCTransaction::StatusComplete) { setError(mTransaction->statusMessage(), mTransaction->statusURI()); } else { switch (mTransactionType) { case TransactionCurrency: finishCurrencyInfo(); break; case TransactionBuy: finishCurrencyBuy(); break; default: ; } } delete mTransaction; mTransaction = NULL; mTransactionType = TransactionNone; return true; } void LLCurrencyUIManager::Impl::setError( const std::string& message, const std::string& uri) { mError = true; mErrorMessage = message; mErrorURI = uri; } void LLCurrencyUIManager::Impl::clearError() { mError = false; mErrorMessage.clear(); mErrorURI.clear(); } bool LLCurrencyUIManager::Impl::considerUpdateCurrency() { if (mCurrencyChanged && !mTransaction && mCurrencyKeyTimer.getElapsedTimeF32() >= CURRENCY_ESTIMATE_FREQUENCY) { updateCurrencyInfo(); return true; } return false; } void LLCurrencyUIManager::Impl::currencyKey(S32 value) { mUserEnteredCurrencyBuy = true; mCurrencyKeyTimer.reset(); if (mUserCurrencyBuy == value) { return; } mUserCurrencyBuy = value; if (hasEstimate()) { clearEstimate(); //cannot just simply refresh the whole UI, as the edit field will // get reset and the cursor will change... mPanel.childHide("currency_est"); mPanel.childSetVisible("getting_data",TRUE); } mCurrencyChanged = true; } // static void LLCurrencyUIManager::Impl::onCurrencyKey( LLLineEditor* caller, void* data) { S32 value = atoi(caller->getText().c_str()); LLCurrencyUIManager::Impl* self = (LLCurrencyUIManager::Impl*)data; self->currencyKey(value); } void LLCurrencyUIManager::Impl::prepare() { LLLineEditor* lindenAmount = mPanel.getChild<LLLineEditor>("currency_amt"); if (lindenAmount) { lindenAmount->setPrevalidate(LLLineEditor::prevalidateNonNegativeS32); lindenAmount->setKeystrokeCallback(onCurrencyKey, this); } } void LLCurrencyUIManager::Impl::updateUI() { if (mHidden) { mPanel.childHide("currency_action"); mPanel.childHide("currency_amt"); mPanel.childHide("currency_est"); return; } mPanel.childShow("currency_action"); LLLineEditor* lindenAmount = mPanel.getChild<LLLineEditor>("currency_amt"); if (lindenAmount) { lindenAmount->setVisible(true); lindenAmount->setLabel(mZeroMessage); if (!mUserEnteredCurrencyBuy) { if (!mZeroMessage.empty() && mUserCurrencyBuy == 0) { lindenAmount->setText(LLStringUtil::null); } else { lindenAmount->setText(llformat("%d", mUserCurrencyBuy)); } lindenAmount->selectAll(); } } mPanel.childSetTextArg("currency_est", "[LOCALAMOUNT]", getLocalEstimate()); mPanel.childSetVisible("currency_est", hasEstimate() && mUserCurrencyBuy > 0); mPanel.childSetVisible("currency_links", mSupportsInternationalBilling); mPanel.childSetVisible("exchange_rate_note", mSupportsInternationalBilling); if (mPanel.childIsEnabled("buy_btn") ||mPanel.childIsVisible("currency_est") || mPanel.childIsVisible("error_web")) { mPanel.childSetVisible("getting_data",FALSE); } } LLCurrencyUIManager::LLCurrencyUIManager(LLPanel& dialog) : impl(* new Impl(dialog)) { } LLCurrencyUIManager::~LLCurrencyUIManager() { delete &impl; } void LLCurrencyUIManager::setAmount(int amount, bool noEstimate) { impl.mUserCurrencyBuy = amount; impl.mUserEnteredCurrencyBuy = false; impl.updateUI(); impl.mCurrencyChanged = !noEstimate; } int LLCurrencyUIManager::getAmount() { return impl.mUserCurrencyBuy; } void LLCurrencyUIManager::setZeroMessage(const std::string& message) { impl.mZeroMessage = message; } void LLCurrencyUIManager::setUSDEstimate(int amount) { impl.mUSDCurrencyEstimatedCost = amount; impl.mUSDCurrencyEstimated = true; impl.updateUI(); impl.mCurrencyChanged = false; } int LLCurrencyUIManager::getUSDEstimate() { return impl.mUSDCurrencyEstimated ? impl.mUSDCurrencyEstimatedCost : 0; } void LLCurrencyUIManager::setLocalEstimate(const std::string &amount) { impl.mLocalCurrencyEstimatedCost = amount; impl.mLocalCurrencyEstimated = true; impl.updateUI(); impl.mCurrencyChanged = false; } std::string LLCurrencyUIManager::getLocalEstimate() const { return impl.getLocalEstimate(); } void LLCurrencyUIManager::prepare() { impl.prepare(); } void LLCurrencyUIManager::updateUI(bool show) { impl.mHidden = !show; impl.updateUI(); } bool LLCurrencyUIManager::process() { bool changed = false; changed |= impl.checkTransaction(); changed |= impl.considerUpdateCurrency(); return changed; } void LLCurrencyUIManager::buy(const std::string& buy_msg) { if (!canBuy()) { return; } LLUIString msg = buy_msg; msg.setArg("[LINDENS]", llformat("%d", impl.mUserCurrencyBuy)); msg.setArg("[LOCALAMOUNT]", getLocalEstimate()); LLConfirmationManager::confirm(impl.mSiteConfirm, msg, impl, &LLCurrencyUIManager::Impl::startCurrencyBuy); } bool LLCurrencyUIManager::inProcess() { return impl.mTransactionType != Impl::TransactionNone; } bool LLCurrencyUIManager::canCancel() { return impl.mTransactionType != Impl::TransactionBuy; } bool LLCurrencyUIManager::canBuy() { return impl.mTransactionType == Impl::TransactionNone && impl.hasEstimate() && impl.mUserCurrencyBuy > 0; } bool LLCurrencyUIManager::buying() { return impl.mTransactionType == Impl::TransactionBuy; } bool LLCurrencyUIManager::bought() { return impl.mBought; } bool LLCurrencyUIManager::hasError() { return impl.mError; } std::string LLCurrencyUIManager::errorMessage() { return impl.mErrorMessage; } std::string LLCurrencyUIManager::errorURI() { return impl.mErrorURI; }