summaryrefslogtreecommitdiffstats
path: root/kmymoney2/wizards/newaccountwizard/knewaccountwizard.cpp
diff options
context:
space:
mode:
authortpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2011-07-04 22:38:03 +0000
committertpearson <tpearson@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2011-07-04 22:38:03 +0000
commitdadc34655c3ab961b0b0b94a10eaaba710f0b5e8 (patch)
tree99e72842fe687baea16376a147619b6048d7e441 /kmymoney2/wizards/newaccountwizard/knewaccountwizard.cpp
downloadkmymoney-dadc34655c3ab961b0b0b94a10eaaba710f0b5e8.tar.gz
kmymoney-dadc34655c3ab961b0b0b94a10eaaba710f0b5e8.zip
Added kmymoney
git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kmymoney@1239792 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kmymoney2/wizards/newaccountwizard/knewaccountwizard.cpp')
-rw-r--r--kmymoney2/wizards/newaccountwizard/knewaccountwizard.cpp1691
1 files changed, 1691 insertions, 0 deletions
diff --git a/kmymoney2/wizards/newaccountwizard/knewaccountwizard.cpp b/kmymoney2/wizards/newaccountwizard/knewaccountwizard.cpp
new file mode 100644
index 0000000..1bfae86
--- /dev/null
+++ b/kmymoney2/wizards/newaccountwizard/knewaccountwizard.cpp
@@ -0,0 +1,1691 @@
+/***************************************************************************
+ knewaccountwizard.cpp
+ -------------------
+ begin : Tue Sep 25 2006
+ copyright : (C) 2007 Thomas Baumgart
+ email : Thomas Baumgart <ipwizard@users.sourceforge.net>
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ ***************************************************************************/
+
+#include <locale.h>
+
+// ----------------------------------------------------------------------------
+// QT Includes
+
+#include <qcheckbox.h>
+#include <qfocusdata.h>
+#include <qtooltip.h>
+#include <qwhatsthis.h>
+#include <qlabel.h>
+
+// ----------------------------------------------------------------------------
+// KDE Includes
+
+#include <klocale.h>
+#include <klistbox.h>
+#include <klineedit.h>
+#include <kmessagebox.h>
+#include <knuminput.h>
+
+// ----------------------------------------------------------------------------
+// Project Includes
+
+#include <kmymoney/kmymoneycombo.h>
+#include <kmymoney/kmymoneyedit.h>
+#include <kmymoney/kmymoneycategory.h>
+#include <kmymoney/mymoneyfile.h>
+#include <kmymoney/kmymoneycurrencyselector.h>
+#include <kmymoney/kmymoneyaccountselector.h>
+#include <kmymoney/kmymoneyaccounttree.h>
+#include <kmymoney/mymoneyfinancialcalculator.h>
+#include <kmymoney/kmymoneychecklistitem.h>
+#include <kmymoney/kmymoneylistviewitem.h>
+#include <kmymoney/kcurrencycalculator.h>
+#include <kmymoney/mymoneyaccount.h>
+#include <kmymoney/kmymoneyglobalsettings.h>
+
+#include "knewaccountwizard.h"
+#include "knewaccountwizard_p.h"
+#include <kmymoney/kguiutils.h>
+
+#include "../../dialogs/ksplittransactiondlg.h"
+#include "../../dialogs/kequitypriceupdatedlg.h"
+#include "../../kmymoney2.h"
+
+using namespace NewAccountWizard;
+
+namespace NewAccountWizard {
+ enum steps {
+ StepInstitution = 1,
+ StepAccount,
+ StepBroker,
+ StepDetails,
+ StepPayments,
+ StepFees,
+ StepSchedule,
+ StepPayout,
+ StepParentAccount,
+ StepFinish
+ };
+};
+NewAccountWizard::Wizard::Wizard(QWidget *parent, const char *name, bool modal, WFlags flags)
+ : KMyMoneyWizard(parent, name, modal, flags)
+{
+ setTitle(i18n("KMyMoney New Account Setup"));
+ addStep(i18n("Institution"));
+ addStep(i18n("Account"));
+ addStep(i18n("Broker"));
+ addStep(i18n("Details"));
+ addStep(i18n("Payments"));
+ addStep(i18n("Fees"));
+ addStep(i18n("Schedule"));
+ addStep(i18n("Payout"));
+ addStep(i18n("Parent Account"));
+ addStep(i18n("Finish"));
+ setStepHidden(StepBroker);
+ setStepHidden(StepSchedule);
+ setStepHidden(StepPayout);
+ setStepHidden(StepDetails);
+ setStepHidden(StepPayments);
+ setStepHidden(StepFees);
+
+ m_institutionPage = new InstitutionPage(this);
+ m_accountTypePage = new AccountTypePage(this);
+ // Investment Pages
+ m_brokeragepage = new BrokeragePage(this);
+ // Credit Card Pages
+ m_schedulePage = new CreditCardSchedulePage(this);
+ // Loan Pages
+ m_generalLoanInfoPage = new GeneralLoanInfoPage(this);
+ m_loanDetailsPage = new LoanDetailsPage(this);
+ m_loanPaymentPage = new LoanPaymentPage(this);
+ m_loanSchedulePage = new LoanSchedulePage(this);
+ m_loanPayoutPage = new LoanPayoutPage(this);
+ // Not a loan page
+ m_hierarchyPage = new HierarchyPage(this);
+ // Finish
+ m_accountSummaryPage = new AccountSummaryPage(this);
+
+ setFirstPage(m_institutionPage);
+}
+
+void NewAccountWizard::Wizard::setAccount(const MyMoneyAccount& acc)
+{
+ m_account = acc;
+ m_accountTypePage->setAccount(m_account);
+}
+
+const MyMoneySecurity& NewAccountWizard::Wizard::currency(void) const
+{
+ return m_accountTypePage->currency();
+}
+
+MyMoneyMoney NewAccountWizard::Wizard::interestRate(void) const
+{
+ return m_loanDetailsPage->m_interestRate->value() / MyMoneyMoney(100,1);
+}
+
+int NewAccountWizard::Wizard::precision(void) const
+{
+ return MyMoneyMoney::denomToPrec(currency().smallestAccountFraction());
+}
+
+const MyMoneyAccount& NewAccountWizard::Wizard::account(void)
+{
+ m_account = MyMoneyAccountLoan();
+ m_account.setName(m_accountTypePage->m_accountName->text());
+ m_account.setOpeningDate(m_accountTypePage->m_openingDate->date());
+ m_account.setAccountType(m_accountTypePage->accountType());
+ m_account.setInstitutionId(m_institutionPage->institution().id());
+ m_account.setNumber(m_institutionPage->m_accountNumber->text());
+ m_account.setValue("IBAN", m_institutionPage->m_iban->text());
+ if(m_accountTypePage->m_preferredAccount->isChecked())
+ m_account.setValue("PreferredAccount", "Yes");
+ else
+ m_account.deletePair("PreferredAccount");
+
+ m_account.setCurrencyId(currency().id());
+ if(m_account.isLoan()) {
+ // in case we lend the money we adjust the account type
+ if(!moneyBorrowed())
+ m_account.setAccountType(MyMoneyAccount::AssetLoan);
+ m_account.setLoanAmount(m_loanDetailsPage->m_loanAmount->value());
+ m_account.setInterestRate(m_account.openingDate(), m_loanDetailsPage->m_interestRate->value());
+ m_account.setInterestCalculation(m_loanDetailsPage->m_paymentDue->currentItem() == 0 ? MyMoneyAccountLoan::paymentReceived : MyMoneyAccountLoan::paymentDue);
+ m_account.setFixedInterestRate(m_generalLoanInfoPage->m_interestType->currentItem() == 0);
+ m_account.setFinalPayment(m_loanDetailsPage->m_balloonAmount->value());
+ m_account.setTerm(m_loanDetailsPage->term());
+ m_account.setPeriodicPayment(m_loanDetailsPage->m_paymentAmount->value());
+ m_account.setPayee(m_generalLoanInfoPage->m_payee->selectedItem());
+ m_account.setInterestCompounding(m_generalLoanInfoPage->m_compoundFrequency->currentItem());
+
+ if(!m_account.fixedInterestRate()) {
+ m_account.setNextInterestChange(m_generalLoanInfoPage->m_interestChangeDateEdit->date());
+ m_account.setInterestChangeFrequency(m_generalLoanInfoPage->m_interestFrequencyAmountEdit->value(), m_generalLoanInfoPage->m_interestFrequencyUnitEdit->currentItem());
+ }
+ }
+ return m_account;
+}
+
+MyMoneyTransaction NewAccountWizard::Wizard::payoutTransaction(void)
+{
+ MyMoneyTransaction t;
+ if(m_account.isLoan() // we're creating a loan
+ && openingBalance().isZero() // and don't have an opening balance
+ && !m_loanPayoutPage->m_noPayoutTransaction->isChecked()) { // and the user wants to have a payout transaction
+ t.setPostDate(m_loanPayoutPage->m_payoutDate->date());
+ t.setCommodity(m_account.currencyId());
+ MyMoneySplit s;
+ s.setAccountId(m_account.id());
+ s.setShares(m_loanDetailsPage->m_loanAmount->value());
+ if(moneyBorrowed())
+ s.setShares(-s.shares());
+ s.setValue(s.shares());
+ t.addSplit(s);
+
+ s.clearId();
+ s.setValue(-s.value());
+ s.setAccountId(m_loanPayoutPage->payoutAccountId());
+ MyMoneyMoney shares;
+ KCurrencyCalculator::setupSplitPrice(shares, t, s, QMap<QString, MyMoneyMoney>(), this);
+ s.setShares(shares);
+ t.addSplit(s);
+ }
+ return t;
+}
+
+const MyMoneyAccount& NewAccountWizard::Wizard::parentAccount(void)
+{
+ return m_accountTypePage->allowsParentAccount()
+ ? m_hierarchyPage->parentAccount()
+ : ( m_accountTypePage->accountType() == MyMoneyAccount::Loan
+ ? m_generalLoanInfoPage->parentAccount()
+ : m_accountTypePage->parentAccount() );
+}
+
+MyMoneyAccount NewAccountWizard::Wizard::brokerageAccount(void) const
+{
+ MyMoneyAccount account;
+ if(m_account.accountType() == MyMoneyAccount::Investment
+ && m_brokeragepage->m_createBrokerageButton->isChecked()) {
+ account.setName(m_account.brokerageName());
+ account.setAccountType(MyMoneyAccount::Checkings);
+ account.setInstitutionId(m_account.institutionId());
+ account.setOpeningDate(m_account.openingDate());
+ account.setCurrencyId(m_brokeragepage->m_brokerageCurrency->security().id());
+ if(m_brokeragepage->m_accountNumber->isEnabled() && !m_brokeragepage->m_accountNumber->text().isEmpty())
+ account.setNumber(m_brokeragepage->m_accountNumber->text());
+ if(m_brokeragepage->m_iban->isEnabled() && !m_brokeragepage->m_iban->text().isEmpty())
+ account.setValue("IBAN", m_brokeragepage->m_iban->text());
+ }
+ return account;
+}
+
+const MyMoneySchedule& NewAccountWizard::Wizard::schedule(void)
+{
+ m_schedule = MyMoneySchedule();
+
+ if(!m_account.id().isEmpty()) {
+ if(m_schedulePage->m_reminderCheckBox->isChecked() && (m_account.accountType() == MyMoneyAccount::CreditCard)) {
+ m_schedule.setName(m_schedulePage->m_name->text());
+ m_schedule.setType(MyMoneySchedule::TYPE_TRANSFER);
+ m_schedule.setPaymentType(static_cast<MyMoneySchedule::paymentTypeE>(m_schedulePage->m_method->currentItem()));
+ m_schedule.setFixed(false);
+ m_schedule.setOccurencePeriod(MyMoneySchedule::OCCUR_MONTHLY);
+ m_schedule.setOccurenceMultiplier(1);
+ MyMoneyTransaction t;
+ MyMoneySplit s;
+ s.setPayeeId(m_schedulePage->m_payee->selectedItem());
+ s.setAccountId(m_schedulePage->m_paymentAccount->selectedItem());
+ s.setMemo(i18n("Credit card payment"));
+ s.setShares(-m_schedulePage->m_amount->value());
+ s.setValue(s.shares());
+ t.addSplit(s);
+
+ s.clearId();
+ s.setAccountId(m_account.id());
+ s.setShares(m_schedulePage->m_amount->value());
+ s.setValue(s.shares());
+ t.addSplit(s);
+
+ // setup the next due date
+ t.setPostDate(m_schedulePage->m_date->date());
+ m_schedule.setTransaction(t);
+
+ } else if(m_account.isLoan()) {
+ m_schedule.setName(i18n("Loan payment for %1").arg(m_accountTypePage->m_accountName->text()));
+ m_schedule.setType(MyMoneySchedule::TYPE_LOANPAYMENT);
+ if(moneyBorrowed())
+ m_schedule.setPaymentType(MyMoneySchedule::STYPE_DIRECTDEBIT);
+ else
+ m_schedule.setPaymentType(MyMoneySchedule::STYPE_DIRECTDEPOSIT);
+
+ m_schedule.setFixed(true);
+ m_schedule.setOccurence(m_generalLoanInfoPage->m_paymentFrequency->currentItem());
+
+ MyMoneyTransaction t;
+ MyMoneySplit s;
+ // payment split
+ s.setPayeeId(m_generalLoanInfoPage->m_payee->selectedItem());
+ s.setAccountId(m_loanSchedulePage->m_paymentAccount->selectedItem());
+ s.setMemo(i18n("Loan payment"));
+ if(moneyBorrowed()) {
+ s.setShares(-(m_loanPaymentPage->basePayment() + m_loanPaymentPage->additionalFees()));
+ } else {
+ s.setShares(m_loanPaymentPage->basePayment() + m_loanPaymentPage->additionalFees());
+ }
+ s.setValue(s.shares());
+ t.addSplit(s);
+
+ // principal split
+ s.clearId();
+ s.setAccountId(m_account.id());
+ s.setShares(MyMoneyMoney::autoCalc);
+ s.setValue(MyMoneyMoney::autoCalc);
+ s.setMemo(i18n("Amortization"));
+ s.setAction(MyMoneySplit::ActionAmortization);
+ t.addSplit(s);
+
+ // interest split
+ s.clearId();
+ s.setAccountId(m_loanSchedulePage->m_interestCategory->selectedItem());
+ s.setShares(MyMoneyMoney::autoCalc);
+ s.setValue(MyMoneyMoney::autoCalc);
+ s.setMemo(i18n("Interest"));
+ s.setAction(MyMoneySplit::ActionInterest);
+ t.addSplit(s);
+
+ // additional fee splits
+ QValueList<MyMoneySplit> additionalSplits;
+ m_loanPaymentPage->additionalFeesSplits(additionalSplits);
+ QValueList<MyMoneySplit>::const_iterator it;
+ MyMoneyMoney factor(moneyBorrowed() ? 1 : -1, 1);
+
+ for(it = additionalSplits.begin(); it != additionalSplits.end(); ++it) {
+ s = (*it);
+ s.clearId();
+ s.setShares(s.shares() * factor);
+ s.setValue(s.value() * factor);
+ t.addSplit(s);
+ }
+
+ // setup the next due date
+ t.setPostDate(m_loanSchedulePage->firstPaymentDueDate());
+ m_schedule.setTransaction(t);
+ }
+ }
+ return m_schedule;
+}
+
+MyMoneyMoney NewAccountWizard::Wizard::openingBalance(void) const
+{
+ // equity accounts don't have an opening balance
+ if(m_accountTypePage->accountType() == MyMoneyAccount::Equity)
+ return MyMoneyMoney();
+
+ if(m_accountTypePage->accountType() == MyMoneyAccount::Loan) {
+ if(m_generalLoanInfoPage->recordAllPayments())
+ return MyMoneyMoney(0, 1);
+ if(moneyBorrowed())
+ return -(m_generalLoanInfoPage->m_openingBalance->value());
+ return m_generalLoanInfoPage->m_openingBalance->value();
+ }
+ return m_accountTypePage->m_openingBalance->value();
+}
+
+MyMoneyPrice NewAccountWizard::Wizard::conversionRate(void) const
+{
+ if(MyMoneyFile::instance()->baseCurrency().id() == m_accountTypePage->m_currencyComboBox->security().id())
+ return MyMoneyPrice(MyMoneyFile::instance()->baseCurrency().id(),
+ m_accountTypePage->m_currencyComboBox->security().id(),
+ m_accountTypePage->m_openingDate->date(),
+ MyMoneyMoney(1,1),
+ i18n("User"));
+ return MyMoneyPrice(MyMoneyFile::instance()->baseCurrency().id(),
+ m_accountTypePage->m_currencyComboBox->security().id(),
+ m_accountTypePage->m_openingDate->date(),
+ m_accountTypePage->m_conversionRate->value(),
+ i18n("User"));
+}
+
+bool NewAccountWizard::Wizard::moneyBorrowed(void) const
+{
+ return m_generalLoanInfoPage->m_loanDirection->currentItem() == 0;
+}
+
+class NewAccountWizard::InstitutionPage::Private
+{
+public:
+ QValueList<MyMoneyInstitution> m_list;
+};
+
+InstitutionPage::InstitutionPage(Wizard* wizard, const char* name) :
+ KInstitutionPageDecl(wizard),
+ WizardPage<Wizard>(StepInstitution, this, wizard, name),
+ d(new Private())
+{
+ connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadWidgets()));
+ connect(m_newInstitutionButton, SIGNAL(clicked()), this, SLOT(slotNewInstitution()));
+ connect(m_institutionComboBox, SIGNAL(activated(int)), this, SLOT(slotSelectInstitution(int)));
+
+ slotLoadWidgets();
+ m_institutionComboBox->setCurrentItem(0);
+ slotSelectInstitution(0);
+}
+
+InstitutionPage::~InstitutionPage()
+{
+ delete d;
+}
+
+void InstitutionPage::slotLoadWidgets(void)
+{
+ m_institutionComboBox->clear();
+
+ d->m_list.clear();
+ MyMoneyFile::instance()->institutionList(d->m_list);
+ qHeapSort(d->m_list);
+
+ QValueList<MyMoneyInstitution>::const_iterator it_l;
+ m_institutionComboBox->insertItem("");
+ for(it_l = d->m_list.begin(); it_l != d->m_list.end(); ++it_l) {
+ m_institutionComboBox->insertItem((*it_l).name());
+ }
+}
+
+void InstitutionPage::slotNewInstitution(void)
+{
+ MyMoneyInstitution institution;
+
+ emit m_wizard->createInstitution(institution);
+
+ if(!institution.id().isEmpty()) {
+ QValueList<MyMoneyInstitution>::const_iterator it_l;
+ int i = 0;
+ for(it_l = d->m_list.begin(); it_l != d->m_list.end(); ++it_l) {
+ if((*it_l).id() == institution.id()) {
+ // select the item and remember that the very first one is the empty item
+ m_institutionComboBox->setCurrentItem(i+1);
+ slotSelectInstitution(i+1);
+ m_accountNumber->setFocus();
+ break;
+ }
+ ++i;
+ }
+ }
+}
+
+void InstitutionPage::slotSelectInstitution(int id)
+{
+ m_accountNumber->setEnabled(id != 0);
+ m_iban->setEnabled(id != 0);
+}
+
+const MyMoneyInstitution& InstitutionPage::institution(void) const
+{
+ static MyMoneyInstitution emptyInstitution;
+ if(m_institutionComboBox->currentItem() == 0)
+ return emptyInstitution;
+
+ return d->m_list[m_institutionComboBox->currentItem()-1];
+}
+
+KMyMoneyWizardPage* InstitutionPage::nextPage(void) const
+{
+ return m_wizard->m_accountTypePage;
+}
+
+AccountTypePage::AccountTypePage(Wizard* wizard, const char* name) :
+ KAccountTypePageDecl(wizard),
+ WizardPage<Wizard>(StepAccount, this, wizard, name),
+ m_showPriceWarning(true)
+{
+ m_typeSelection->insertItem(i18n("Checking"), MyMoneyAccount::Checkings);
+ m_typeSelection->insertItem(i18n("Savings"), MyMoneyAccount::Savings);
+ m_typeSelection->insertItem(i18n("Credit Card"), MyMoneyAccount::CreditCard);
+ m_typeSelection->insertItem(i18n("Cash"), MyMoneyAccount::Cash);
+ m_typeSelection->insertItem(i18n("Loan"), MyMoneyAccount::Loan);
+ m_typeSelection->insertItem(i18n("Investment"), MyMoneyAccount::Investment);
+ m_typeSelection->insertItem(i18n("Asset"), MyMoneyAccount::Asset);
+ m_typeSelection->insertItem(i18n("Liability"), MyMoneyAccount::Liability);
+ if(KMyMoneyGlobalSettings::expertMode()) {
+ m_typeSelection->insertItem(i18n("Equity"), MyMoneyAccount::Equity);
+ }
+
+ m_typeSelection->setCurrentItem(MyMoneyAccount::Checkings);
+
+ m_currencyComboBox->setSecurity(MyMoneyFile::instance()->baseCurrency());
+
+ m_mandatoryGroup->add(m_accountName);
+ m_mandatoryGroup->add(m_conversionRate->lineedit());
+
+ m_conversionRate->setPrecision(KMyMoneyGlobalSettings::pricePrecision());
+ m_conversionRate->setValue(MyMoneyMoney(1,1));
+ slotUpdateCurrency();
+
+ connect(m_typeSelection, SIGNAL(itemSelected(int)), this, SLOT(slotUpdateType(int)));
+ connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadWidgets()));
+ connect(m_currencyComboBox, SIGNAL(activated(int)), this, SLOT(slotUpdateCurrency()));
+ connect(m_conversionRate, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateConversionRate(const QString&)));
+ connect(m_conversionRate, SIGNAL(valueChanged(const QString&)), this, SLOT(slotPriceWarning()));
+ connect(m_onlineQuote, SIGNAL(clicked()), this, SLOT(slotGetOnlineQuote()));
+}
+
+void AccountTypePage::slotUpdateType(int i)
+{
+ hideShowPages(static_cast<MyMoneyAccount::accountTypeE> (i));
+ m_openingBalance->setDisabled(static_cast<MyMoneyAccount::accountTypeE> (i) == MyMoneyAccount::Equity);
+}
+
+void AccountTypePage::hideShowPages(MyMoneyAccount::accountTypeE accountType) const
+{
+ bool hideSchedulePage = (accountType != MyMoneyAccount::CreditCard)
+ && (accountType != MyMoneyAccount::Loan);
+ bool hideLoanPage = (accountType != MyMoneyAccount::Loan);
+ m_wizard->setStepHidden(StepDetails, hideLoanPage);
+ m_wizard->setStepHidden(StepPayments, hideLoanPage);
+ m_wizard->setStepHidden(StepFees, hideLoanPage);
+ m_wizard->setStepHidden(StepSchedule, hideSchedulePage);
+ m_wizard->setStepHidden(StepPayout, (accountType != MyMoneyAccount::Loan));
+ m_wizard->setStepHidden(StepBroker, accountType != MyMoneyAccount::Investment);
+ m_wizard->setStepHidden(StepParentAccount, accountType == MyMoneyAccount::Loan);
+ // Force an update of the steps in case the list has changed
+ m_wizard->reselectStep();
+};
+
+KMyMoneyWizardPage* AccountTypePage::nextPage(void) const
+{
+ if(accountType() == MyMoneyAccount::Loan)
+ return m_wizard->m_generalLoanInfoPage;
+ if(accountType() == MyMoneyAccount::CreditCard)
+ return m_wizard->m_schedulePage;
+ if(accountType() == MyMoneyAccount::Investment)
+ return m_wizard->m_brokeragepage;
+ return m_wizard->m_hierarchyPage;
+}
+
+void AccountTypePage::slotUpdateCurrency(void)
+{
+ MyMoneyAccount acc;
+ acc.setAccountType(accountType());
+
+ m_openingBalance->setPrecision(MyMoneyMoney::denomToPrec(acc.fraction(currency())));
+
+ bool show = m_currencyComboBox->security().id() != MyMoneyFile::instance()->baseCurrency().id();
+ m_conversionLabel->setShown(show);
+ m_conversionRate->setShown(show);
+ m_conversionExample->setShown(show);
+ m_onlineQuote->setShown(show);
+ m_conversionRate->setEnabled(show); // make sure to include/exclude in mandatoryGroup
+ m_mandatoryGroup->changed();
+ slotUpdateConversionRate(m_conversionRate->lineedit()->text());
+}
+
+void AccountTypePage::slotGetOnlineQuote(void)
+{
+ QString id = MyMoneyFile::instance()->baseCurrency().id()+" "+m_currencyComboBox->security().id();
+ KEquityPriceUpdateDlg dlg(this, id);
+ if(dlg.exec() == QDialog::Accepted) {
+ MyMoneyPrice price = dlg.price(id);
+ if(price.isValid()) {
+ m_conversionRate->setValue(price.rate(m_currencyComboBox->security().id()));
+ if(price.date() != m_openingDate->date()) {
+ priceWarning(true);
+ }
+ }
+ }
+}
+
+void AccountTypePage::slotPriceWarning(void)
+{
+ priceWarning(false);
+}
+
+void AccountTypePage::priceWarning(bool always)
+{
+ if(m_showPriceWarning || always) {
+ KMessageBox::information(this, i18n("Please make sure to enter the correct conversion for the selected opening date. If you requested an online quote it might be provided for a different date."), i18n("Check date"));
+ }
+ m_showPriceWarning = false;
+}
+
+void AccountTypePage::slotUpdateConversionRate(const QString& txt)
+{
+ m_conversionExample->setText(i18n("1 %1 equals %2").
+ arg(MyMoneyFile::instance()->baseCurrency().tradingSymbol()).
+ arg(MyMoneyMoney(txt).formatMoney(m_currencyComboBox->security().tradingSymbol(), KMyMoneyGlobalSettings::pricePrecision())));
+}
+
+void AccountTypePage::slotLoadWidgets(void)
+{
+ m_currencyComboBox->update(QString("x"));
+}
+
+bool AccountTypePage::isComplete(void) const
+{
+ // check that the conversion rate is positive if enabled
+ bool rc = !m_conversionRate->isVisible() || (!m_conversionRate->value().isZero() && !m_conversionRate->value().isNegative());
+ if(!rc) {
+ QToolTip::add(m_wizard->m_nextButton, i18n("Conversion rate is not positive"));
+
+ } else {
+ rc = KMyMoneyWizardPage::isComplete();
+
+ if(!rc) {
+ QToolTip::add(m_wizard->m_nextButton, i18n("No account name supplied"));
+ }
+ }
+ hideShowPages(accountType());
+ return rc;
+}
+
+MyMoneyAccount::accountTypeE AccountTypePage::accountType(void) const
+{
+ return static_cast<MyMoneyAccount::accountTypeE>(m_typeSelection->currentItem());
+}
+
+const MyMoneySecurity& AccountTypePage::currency(void) const
+{
+ return m_currencyComboBox->security();
+}
+
+void AccountTypePage::setAccount(const MyMoneyAccount& acc)
+{
+ m_typeSelection->setCurrentItem(acc.accountType());
+ m_openingDate->setDate(acc.openingDate());
+ m_accountName->setText(acc.name());
+}
+
+const MyMoneyAccount& AccountTypePage::parentAccount(void)
+{
+ switch(accountType()) {
+ case MyMoneyAccount::CreditCard:
+ case MyMoneyAccount::Liability:
+ case MyMoneyAccount::Loan: // Can be either but we return liability here
+ return MyMoneyFile::instance()->liability();
+ break;
+ case MyMoneyAccount::Equity:
+ return MyMoneyFile::instance()->equity();
+ default:
+ break;
+ }
+ return MyMoneyFile::instance()->asset();
+}
+
+bool AccountTypePage::allowsParentAccount(void) const
+{
+ return accountType() != MyMoneyAccount::Loan;
+}
+
+BrokeragePage::BrokeragePage(Wizard* wizard, const char* name) :
+ KBrokeragePageDecl(wizard),
+ WizardPage<Wizard>(StepBroker, this, wizard, name)
+{
+ connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadWidgets()));
+}
+
+void BrokeragePage::slotLoadWidgets(void)
+{
+ m_brokerageCurrency->update(QString("x"));
+}
+
+void BrokeragePage::enterPage(void)
+{
+ // assign the currency of the investment account to the
+ // brokerage account if nothing else has ever been selected
+ if(m_brokerageCurrency->security().id().isEmpty()) {
+ m_brokerageCurrency->setSecurity(m_wizard->m_accountTypePage->m_currencyComboBox->security());
+ }
+
+ // check if the institution relevant fields should be enabled or not
+ bool enabled = m_wizard->m_institutionPage->m_accountNumber->isEnabled();
+ m_accountNumberLabel->setEnabled(enabled);
+ m_accountNumber->setEnabled(enabled);
+ m_ibanLabel->setEnabled(enabled);
+ m_iban->setEnabled(enabled);
+}
+
+KMyMoneyWizardPage* BrokeragePage::nextPage(void) const
+{
+ return m_wizard->m_hierarchyPage;
+}
+
+CreditCardSchedulePage::CreditCardSchedulePage(Wizard* wizard, const char* name) :
+ KSchedulePageDecl(wizard),
+ WizardPage<Wizard>(StepSchedule, this, wizard, name)
+{
+ m_mandatoryGroup->add(m_name);
+ m_mandatoryGroup->add(m_payee);
+ m_mandatoryGroup->add(m_amount->lineedit());
+ m_mandatoryGroup->add(m_paymentAccount);
+ connect(m_paymentAccount, SIGNAL(itemSelected(const QString&)), object(), SIGNAL(completeStateChanged()));
+ connect(m_payee, SIGNAL(itemSelected(const QString&)), object(), SIGNAL(completeStateChanged()));
+ connect(m_date, SIGNAL(dateChanged(const QDate&)), object(), SIGNAL(completeStateChanged()));
+
+ connect(m_payee, SIGNAL(createItem(const QString&, QString&)), wizard, SIGNAL(createPayee(const QString&, QString&)));
+
+ m_reminderCheckBox->setChecked(true);
+ connect(m_reminderCheckBox, SIGNAL(toggled(bool)), object(), SIGNAL(completeStateChanged()));
+
+ connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadWidgets()));
+
+ m_method->insertItem(i18n("Write check"), MyMoneySchedule::STYPE_WRITECHEQUE);
+#if 0
+ m_method->insertItem(i18n("Direct debit"), MyMoneySchedule::STYPE_DIRECTDEBIT);
+ m_method->insertItem(i18n("Bank transfer"), MyMoneySchedule::STYPE_BANKTRANSFER);
+#endif
+ m_method->insertItem(i18n("Standing order"), MyMoneySchedule::STYPE_STANDINGORDER);
+ m_method->insertItem(i18n("Manual deposit"), MyMoneySchedule::STYPE_MANUALDEPOSIT);
+ m_method->insertItem(i18n("Direct deposit"), MyMoneySchedule::STYPE_DIRECTDEPOSIT);
+ m_method->insertItem(i18n("Other"), MyMoneySchedule::STYPE_OTHER);
+ m_method->setCurrentItem(MyMoneySchedule::STYPE_DIRECTDEBIT);
+
+ slotLoadWidgets();
+}
+
+void CreditCardSchedulePage::enterPage(void)
+{
+ if(m_name->text().isEmpty())
+ m_name->setText(i18n("CreditCard %1 monthly payment").arg(m_wizard->m_accountTypePage->m_accountName->text()));
+}
+
+bool CreditCardSchedulePage::isComplete(void) const
+{
+ bool rc = true;
+ QString msg = i18n("Finish entry and create account");
+ if(m_reminderCheckBox->isChecked()) {
+ msg = i18n("Finish entry and create account and schedule");
+ if(m_date->date() < m_wizard->m_accountTypePage->m_openingDate->date()) {
+ rc = false;
+ msg = i18n("Next due date is prior to opening date");
+ }
+ if(m_paymentAccount->selectedItem().isEmpty()) {
+ rc = false;
+ msg = i18n("No account selected");
+ }
+ if(m_amount->lineedit()->text().isEmpty()) {
+ rc = false;
+ msg = i18n("No amount for payment selected");
+ }
+ if(m_payee->selectedItem().isEmpty()) {
+ rc = false;
+ msg = i18n("No payee for payment selected");
+ }
+ if(m_name->text().isEmpty()) {
+ rc = false;
+ msg = i18n("No name assigned for schedule");
+ }
+ }
+ QToolTip::add(m_wizard->m_finishButton, msg);
+
+ return rc;
+}
+
+void CreditCardSchedulePage::slotLoadWidgets(void)
+{
+ AccountSet set;
+ set.addAccountGroup(MyMoneyAccount::Asset);
+ set.load(m_paymentAccount->selector());
+
+ m_payee->loadPayees(MyMoneyFile::instance()->payeeList());
+}
+
+KMyMoneyWizardPage* CreditCardSchedulePage::nextPage(void) const
+{
+ return m_wizard->m_hierarchyPage;
+}
+
+GeneralLoanInfoPage::GeneralLoanInfoPage(Wizard* wizard, const char* name) :
+ KGeneralLoanInfoPageDecl(wizard),
+ WizardPage<Wizard>(StepDetails, this, wizard, name),
+ m_firstTime(true)
+{
+ m_mandatoryGroup->add(m_payee);
+
+ // remove the unsupported payment and compounding frequencies and setup default
+ m_paymentFrequency->removeItem(MyMoneySchedule::OCCUR_ONCE);
+ m_paymentFrequency->removeItem(MyMoneySchedule::OCCUR_EVERYOTHERYEAR);
+ m_paymentFrequency->setCurrentItem(MyMoneySchedule::OCCUR_MONTHLY);
+ m_compoundFrequency->removeItem(MyMoneySchedule::OCCUR_ONCE);
+ m_compoundFrequency->removeItem(MyMoneySchedule::OCCUR_EVERYOTHERYEAR);
+ m_compoundFrequency->setCurrentItem(MyMoneySchedule::OCCUR_MONTHLY);
+
+ slotLoadWidgets();
+
+ connect(m_payee, SIGNAL(createItem(const QString&, QString&)), wizard, SIGNAL(createPayee(const QString&, QString&)));
+ connect(m_anyPayments, SIGNAL(activated(int)), object(), SIGNAL(completeStateChanged()));
+ connect(m_recordings, SIGNAL(activated(int)), object(), SIGNAL(completeStateChanged()));
+
+ connect(m_interestType, SIGNAL(activated(int)), object(), SIGNAL(completeStateChanged()));
+ connect(m_interestChangeDateEdit, SIGNAL(dateChanged(const QDate&)), object(), SIGNAL(completeStateChanged()));
+ connect(m_openingBalance, SIGNAL(textChanged(const QString&)), object(), SIGNAL(completeStateChanged()));
+
+ connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadWidgets()));
+}
+
+KMyMoneyWizardPage* GeneralLoanInfoPage::nextPage(void) const
+{
+ return m_wizard->m_loanDetailsPage;
+}
+
+bool GeneralLoanInfoPage::recordAllPayments(void) const
+{
+ bool rc = true; // all payments
+ if(m_recordings->isEnabled()) {
+ if(m_recordings->currentItem() != 0)
+ rc = false;
+ }
+ return rc;
+}
+
+void GeneralLoanInfoPage::enterPage(void)
+{
+ if(m_firstTime) {
+ // setup default dates to last of this month and one year on top
+ QDate firstDay(QDate::currentDate().year(), QDate::currentDate().month(), 1);
+ m_firstPaymentDate->setDate(firstDay.addMonths(1).addDays(-1));
+ m_interestChangeDateEdit->setDate(m_firstPaymentDate->date().addYears(1));;
+ m_firstTime = false;
+ }
+}
+
+bool GeneralLoanInfoPage::isComplete(void) const
+{
+ m_wizard->setStepHidden(StepPayout, !m_wizard->openingBalance().isZero());
+ bool rc = KMyMoneyWizardPage::isComplete();
+ if(!rc) {
+ QToolTip::add(m_wizard->m_nextButton, i18n("No payee supplied"));
+ }
+
+ // fixup availability of items on this page
+ m_recordings->setDisabled(m_anyPayments->currentItem() == 0);
+
+ m_interestFrequencyAmountEdit->setDisabled(m_interestType->currentItem() == 0);
+ m_interestFrequencyUnitEdit->setDisabled(m_interestType->currentItem() == 0);
+ m_interestChangeDateEdit->setDisabled(m_interestType->currentItem() == 0);
+
+ m_openingBalance->setDisabled(recordAllPayments());
+
+ if(m_openingBalance->isEnabled() && m_openingBalance->lineedit()->text().length() == 0) {
+ rc = false;
+ QToolTip::add(m_wizard->m_nextButton, i18n("No opening balance supplied"));
+ }
+
+ if(rc
+ && (m_interestType->currentItem() != 0)
+ && (m_interestChangeDateEdit->date() <= m_firstPaymentDate->date())) {
+ rc = false;
+ QToolTip::add(m_wizard->m_nextButton, i18n("An interest change can only happen after the first payment"));
+ }
+ return rc;
+}
+
+const MyMoneyAccount& GeneralLoanInfoPage::parentAccount(void)
+{
+ return ( m_loanDirection->currentItem() == 0 )
+ ? MyMoneyFile::instance()->liability()
+ : MyMoneyFile::instance()->asset();
+}
+
+void GeneralLoanInfoPage::slotLoadWidgets(void)
+{
+ m_payee->loadPayees(MyMoneyFile::instance()->payeeList());
+}
+
+LoanDetailsPage::LoanDetailsPage(Wizard* wizard, const char* name) :
+ KLoanDetailsPageDecl(wizard),
+ WizardPage<Wizard>(StepPayments, this, wizard, name),
+ m_needCalculate(true)
+{
+ // force the balloon payment to zero (default)
+ m_balloonAmount->setValue(MyMoneyMoney());
+ // allow any precision for the interest rate
+ m_interestRate->setPrecision(-1);
+
+ connect(m_paymentDue, SIGNAL(activated(int)), this, SLOT(slotValuesChanged()));
+
+ connect(m_termAmount, SIGNAL(valueChanged(int)), this, SLOT(slotValuesChanged()));
+ connect(m_termUnit, SIGNAL(highlighted(int)), this, SLOT(slotValuesChanged()));
+ connect(m_loanAmount, SIGNAL(textChanged(const QString&)), this, SLOT(slotValuesChanged()));
+ connect(m_interestRate, SIGNAL(textChanged(const QString&)), this, SLOT(slotValuesChanged()));
+ connect(m_paymentAmount, SIGNAL(textChanged(const QString&)), this, SLOT(slotValuesChanged()));
+ connect(m_balloonAmount, SIGNAL(textChanged(const QString&)), this, SLOT(slotValuesChanged()));
+
+ connect(m_calculateButton, SIGNAL(clicked()), this, SLOT(slotCalculate()));
+}
+
+void LoanDetailsPage::enterPage(void)
+{
+ // we need to remove a bunch of entries of the payment frequencies
+ m_termUnit->clear();
+
+ m_mandatoryGroup->clear();
+ if(!m_wizard->openingBalance().isZero()) {
+ m_mandatoryGroup->add(m_loanAmount->lineedit());
+ if(m_loanAmount->lineedit()->text().length() == 0) {
+ m_loanAmount->setValue(m_wizard->openingBalance().abs());
+ }
+ }
+
+ switch(m_wizard->m_generalLoanInfoPage->m_paymentFrequency->currentItem()) {
+ default:
+ m_termUnit->insertItem(i18n("Payments"), MyMoneySchedule::OCCUR_ONCE);
+ m_termUnit->setCurrentItem(MyMoneySchedule::OCCUR_ONCE);
+ break;
+ case MyMoneySchedule::OCCUR_MONTHLY:
+ m_termUnit->insertItem(i18n("Months"), MyMoneySchedule::OCCUR_MONTHLY);
+ m_termUnit->insertItem(i18n("Years"), MyMoneySchedule::OCCUR_YEARLY);
+ m_termUnit->setCurrentItem(MyMoneySchedule::OCCUR_MONTHLY);
+ break;
+ case MyMoneySchedule::OCCUR_YEARLY:
+ m_termUnit->insertItem(i18n("Years"), MyMoneySchedule::OCCUR_YEARLY);
+ m_termUnit->setCurrentItem(MyMoneySchedule::OCCUR_YEARLY);
+ break;
+ }
+}
+
+void LoanDetailsPage::slotValuesChanged(void)
+{
+ m_needCalculate = true;
+ m_wizard->completeStateChanged();
+}
+
+void LoanDetailsPage::slotCalculate(void)
+{
+ MyMoneyFinancialCalculator calc;
+ long double val;
+ int PF, CF;
+ QString result;
+ bool moneyBorrowed = m_wizard->moneyBorrowed();
+ bool moneyLend = !moneyBorrowed;
+
+ // FIXME: for now, we only support interest calculation at the end of the period
+ calc.setBep();
+ // FIXME: for now, we only support periodic compounding
+ calc.setDisc();
+
+ PF = m_wizard->m_generalLoanInfoPage->m_paymentFrequency->eventsPerYear();
+ CF = m_wizard->m_generalLoanInfoPage->m_compoundFrequency->eventsPerYear();
+
+ if(PF == 0 || CF == 0)
+ return;
+
+ calc.setPF(PF);
+ calc.setCF(CF);
+
+
+ if(!m_loanAmount->lineedit()->text().isEmpty()) {
+ val = static_cast<long double> (m_loanAmount->value().abs().toDouble());
+ if(moneyBorrowed)
+ val = -val;
+ calc.setPv(val);
+ }
+
+ if(!m_interestRate->lineedit()->text().isEmpty()) {
+ val = static_cast<long double> (m_interestRate->value().abs().toDouble());
+ calc.setIr(val);
+ }
+
+ if(!m_paymentAmount->lineedit()->text().isEmpty()) {
+ val = static_cast<long double> (m_paymentAmount->value().abs().toDouble());
+ if(moneyLend)
+ val = -val;
+ calc.setPmt(val);
+ }
+
+ if(!m_balloonAmount->lineedit()->text().isEmpty()) {
+ val = static_cast<long double> (m_balloonAmount->value().abs().toDouble());
+ if(moneyLend)
+ val = -val;
+ calc.setFv(val);
+ }
+
+ if(m_termAmount->value() != 0) {
+ calc.setNpp(static_cast<long double>(term()));
+ }
+
+ // setup of parameters is done, now do the calculation
+ try {
+ if(m_loanAmount->lineedit()->text().isEmpty()) {
+ // calculate the amount of the loan out of the other information
+ val = calc.presentValue();
+ m_loanAmount->loadText(MyMoneyMoney(static_cast<double>(val)).abs().formatMoney("", m_wizard->precision()));
+ result = i18n("KMyMoney has calculated the amount of the loan as %1.")
+ .arg(m_loanAmount->lineedit()->text());
+
+ } else if(m_interestRate->lineedit()->text().isEmpty()) {
+ // calculate the interest rate out of the other information
+ val = calc.interestRate();
+ m_interestRate->loadText(MyMoneyMoney(static_cast<double>(val)).abs().formatMoney("", 3));
+ result = i18n("KMyMoney has calculated the interest rate to %1%.")
+ .arg(m_interestRate->lineedit()->text());
+
+ } else if(m_paymentAmount->lineedit()->text().isEmpty()) {
+ // calculate the periodical amount of the payment out of the other information
+ val = calc.payment();
+ m_paymentAmount->setValue(MyMoneyMoney(static_cast<double>(val)).abs());
+ // reset payment as it might have changed due to rounding
+ val = static_cast<long double> (m_paymentAmount->value().abs().toDouble());
+ if(moneyLend)
+ val = -val;
+ calc.setPmt(val);
+
+ result = i18n("KMyMoney has calculated a periodic payment of %1 to cover principal and interest.")
+ .arg(m_paymentAmount->lineedit()->text());
+
+ val = calc.futureValue();
+ if((moneyBorrowed && val < 0 && fabsl(val) >= fabsl(calc.payment()))
+ || (moneyLend && val > 0 && fabs(val) >= fabs(calc.payment()))) {
+ calc.setNpp(calc.npp()-1);
+ // updateTermWidgets(calc.npp());
+ val = calc.futureValue();
+ MyMoneyMoney refVal(static_cast<double>(val));
+ m_balloonAmount->loadText(refVal.abs().formatMoney("", m_wizard->precision()));
+ result += QString(" ");
+ result += i18n("The number of payments has been decremented and the balloon payment has been modified to %1.")
+ .arg(m_balloonAmount->lineedit()->text());
+ } else if((moneyBorrowed && val < 0 && fabsl(val) < fabsl(calc.payment()))
+ || (moneyLend && val > 0 && fabs(val) < fabs(calc.payment()))) {
+ m_balloonAmount->loadText(MyMoneyMoney(0,1).formatMoney("", m_wizard->precision()));
+ } else {
+ MyMoneyMoney refVal(static_cast<double>(val));
+ m_balloonAmount->loadText(refVal.abs().formatMoney("", m_wizard->precision()));
+ result += i18n("The balloon payment has been modified to %1.")
+ .arg(m_balloonAmount->lineedit()->text());
+ }
+
+ } else if(m_termAmount->value() == 0) {
+ // calculate the number of payments out of the other information
+ val = calc.numPayments();
+ if(val == 0)
+ throw new MYMONEYEXCEPTION("incorrect fincancial calculation");
+
+ // if the number of payments has a fractional part, then we
+ // round it to the smallest integer and calculate the balloon payment
+ result = i18n("KMyMoney has calculated the term of your loan as %1. ")
+ .arg(updateTermWidgets(floorl(val)));
+
+ if(val != floorl(val)) {
+ calc.setNpp(floorl(val));
+ val = calc.futureValue();
+ MyMoneyMoney refVal(static_cast<double>(val));
+ m_balloonAmount->loadText(refVal.abs().formatMoney("", m_wizard->precision()));
+ result += i18n("The balloon payment has been modified to %1.")
+ .arg(m_balloonAmount->lineedit()->text());
+ }
+
+ } else {
+ // calculate the future value of the loan out of the other information
+ val = calc.futureValue();
+
+ // we differentiate between the following cases:
+ // a) the future value is greater than a payment
+ // b) the future value is less than a payment or the loan is overpaid
+ // c) all other cases
+ //
+ // a) means, we have paid more than we owed. This can't be
+ // b) means, we paid more than we owed but the last payment is
+ // less in value than regular payments. That means, that the
+ // future value is to be treated as (fully payed back)
+ // c) the loan is not payed back yet
+ if((moneyBorrowed && val < 0 && fabsl(val) > fabsl(calc.payment()))
+ || (moneyLend && val > 0 && fabs(val) > fabs(calc.payment()))) {
+ // case a)
+ qDebug("Future Value is %Lf", val);
+ throw new MYMONEYEXCEPTION("incorrect fincancial calculation");
+
+ } else if((moneyBorrowed && val < 0 && fabsl(val) <= fabsl(calc.payment()))
+ || (moneyLend && val > 0 && fabs(val) <= fabs(calc.payment()))) {
+ // case b)
+ val = 0;
+ }
+
+ MyMoneyMoney refVal(static_cast<double>(val));
+ result = i18n("KMyMoney has calculated a balloon payment of %1 for this loan.")
+ .arg(refVal.abs().formatMoney("", m_wizard->precision()));
+
+ if(!m_balloonAmount->lineedit()->text().isEmpty()) {
+ if((m_balloonAmount->value().abs() - refVal.abs()).abs().toDouble() > 1) {
+ throw new MYMONEYEXCEPTION("incorrect fincancial calculation");
+ }
+ result = i18n("KMyMoney has successfully verified your loan information.");
+ }
+ m_balloonAmount->loadText(refVal.abs().formatMoney("", m_wizard->precision()));
+ }
+
+ } catch (MyMoneyException *e) {
+ delete e;
+ KMessageBox::error(0,
+ i18n("You have entered mis-matching information. Please modify "
+ "your figures or leave one value empty "
+ "to let KMyMoney calculate it for you"),
+ i18n("Calculation error"));
+ return;
+ }
+
+ result += i18n("\n\nAccept this or modify the loan information and recalculate.");
+
+ KMessageBox::information(0, result, i18n("Calculation successful"));
+ m_needCalculate = false;
+
+ // now update change
+ m_wizard->completeStateChanged();
+}
+
+int LoanDetailsPage::term(void) const
+{
+ int factor = 0;
+
+ if(m_termAmount->value() != 0) {
+ factor = 1;
+ switch(m_termUnit->currentItem()) {
+ case MyMoneySchedule::OCCUR_YEARLY: // years
+ factor = 12;
+ // tricky fall through here
+
+ case MyMoneySchedule::OCCUR_MONTHLY: // months
+ factor *= 30;
+ factor *= m_termAmount->value();
+ // factor now is the duration in days. we divide this by the
+ // payment frequency and get the number of payments
+ factor /= m_wizard->m_generalLoanInfoPage->m_paymentFrequency->daysBetweenEvents();
+ break;
+
+ default:
+ qDebug("Unknown term unit %d in LoanDetailsPage::term(). Using payments.", m_termUnit->currentItem());
+ // tricky fall through here
+
+ case MyMoneySchedule::OCCUR_ONCE: // payments
+ factor = m_termAmount->value();
+ break;
+ }
+ }
+ return factor;
+}
+
+QString LoanDetailsPage::updateTermWidgets(const long double val)
+{
+ long long vl = static_cast<long long>(floorl(val));
+
+ QString valString;
+ MyMoneySchedule::occurenceE unit = m_termUnit->currentItem();
+
+ if((unit == MyMoneySchedule::OCCUR_MONTHLY)
+ && ((vl % 12) == 0)) {
+ vl /= 12;
+ unit = MyMoneySchedule::OCCUR_YEARLY;
+ }
+
+ switch(unit) {
+ case MyMoneySchedule::OCCUR_MONTHLY:
+ valString = i18n("one month", "%n months", vl);
+ m_termUnit->setCurrentItem(MyMoneySchedule::OCCUR_MONTHLY);
+ break;
+ case MyMoneySchedule::OCCUR_YEARLY:
+ valString = i18n("one year", "%n years", vl);
+ m_termUnit->setCurrentItem(MyMoneySchedule::OCCUR_YEARLY);
+ break;
+ default:
+ valString = i18n("one payment", "%n payments", vl);
+ m_termUnit->setCurrentItem(MyMoneySchedule::OCCUR_ONCE);
+ break;
+ }
+ m_termAmount->setValue(vl);
+ return valString;
+}
+
+bool LoanDetailsPage::isComplete(void) const
+{
+ // bool rc = KMyMoneyWizardPage::isComplete();
+
+ int fieldCnt = 0;
+ QWidget* calculatedField = 0;
+
+ if(m_loanAmount->lineedit()->text().length() > 0) {
+ fieldCnt++;
+ } else {
+ calculatedField = m_loanAmount;
+ }
+
+ if(m_interestRate->lineedit()->text().length() > 0) {
+ fieldCnt++;
+ } else {
+ calculatedField = m_interestRate;
+ }
+
+ if(m_termAmount->value() != 0) {
+ fieldCnt++;
+ } else {
+ calculatedField = m_termAmount;
+ }
+
+ if(m_paymentAmount->lineedit()->text().length() > 0) {
+ fieldCnt++;
+ } else {
+ calculatedField = m_paymentAmount;
+ }
+
+ if(m_balloonAmount->lineedit()->text().length() > 0) {
+ fieldCnt++;
+ } else {
+ calculatedField = m_balloonAmount;
+ }
+
+ if(fieldCnt == 5)
+ calculatedField = 0;
+
+ m_calculateButton->setEnabled(fieldCnt == 4 || (fieldCnt == 5 && m_needCalculate));
+
+ m_calculateButton->setAutoDefault(false);
+ m_calculateButton->setDefault(false);
+ if(m_needCalculate && fieldCnt == 4) {
+ QToolTip::add(m_wizard->m_nextButton, i18n("Press Calculate to verify the values"));
+ m_calculateButton->setAutoDefault(true);
+ m_calculateButton->setDefault(true);
+ } else if(fieldCnt != 5) {
+ QToolTip::add(m_wizard->m_nextButton, i18n("Not all details supplied"));
+ m_calculateButton->setAutoDefault(true);
+ m_calculateButton->setDefault(true);
+ }
+ m_wizard->m_nextButton->setAutoDefault(!m_calculateButton->autoDefault());
+ m_wizard->m_nextButton->setDefault(!m_calculateButton->autoDefault());
+
+ return (fieldCnt == 5) && !m_needCalculate;
+}
+
+KMyMoneyWizardPage* LoanDetailsPage::nextPage(void) const
+{
+ return m_wizard->m_loanPaymentPage;
+}
+
+
+class NewAccountWizard::LoanPaymentPage::Private
+{
+public:
+ MyMoneyAccount phonyAccount;
+ MyMoneySplit phonySplit;
+ MyMoneyTransaction additionalFeesTransaction;
+ MyMoneyMoney additionalFees;
+};
+
+LoanPaymentPage::LoanPaymentPage(Wizard* wizard, const char* name) :
+ KLoanPaymentPageDecl(wizard),
+ WizardPage<Wizard>(StepFees, this, wizard, name),
+ d(new Private)
+{
+ d->phonyAccount = MyMoneyAccount(QString("Phony-ID"), MyMoneyAccount());
+
+ d->phonySplit.setAccountId(d->phonyAccount.id());
+ d->phonySplit.setValue(0);
+ d->phonySplit.setShares(0);
+
+ d->additionalFeesTransaction.addSplit(d->phonySplit);
+
+ connect(m_additionalFeesButton, SIGNAL(clicked()), this, SLOT(slotAdditionalFees()));
+}
+
+LoanPaymentPage::~LoanPaymentPage()
+{
+ delete d;
+}
+
+MyMoneyMoney LoanPaymentPage::basePayment(void) const
+{
+ return m_wizard->m_loanDetailsPage->m_paymentAmount->value();
+}
+
+MyMoneyMoney LoanPaymentPage::additionalFees(void) const
+{
+ return d->additionalFees;
+}
+
+void LoanPaymentPage::additionalFeesSplits(QValueList<MyMoneySplit>& list)
+{
+ list.clear();
+
+ QValueList<MyMoneySplit>::ConstIterator it;
+ for(it = d->additionalFeesTransaction.splits().begin(); it != d->additionalFeesTransaction.splits().end(); ++it) {
+ if((*it).accountId() != d->phonyAccount.id()) {
+ list << (*it);
+ }
+ }
+}
+
+void LoanPaymentPage::updateAmounts(void)
+{
+ m_additionalFees->setText(d->additionalFees.formatMoney(m_wizard->currency().tradingSymbol(), m_wizard->precision()));
+ m_totalPayment->setText((basePayment() + d->additionalFees).formatMoney(m_wizard->currency().tradingSymbol(), m_wizard->precision()));
+}
+
+void LoanPaymentPage::enterPage(void)
+{
+ const MyMoneySecurity& currency = m_wizard->currency();
+
+ m_basePayment->setText(basePayment().formatMoney(currency.tradingSymbol(), m_wizard->precision()));
+ d->phonyAccount.setCurrencyId(currency.id());
+ d->additionalFeesTransaction.setCommodity(currency.id());
+
+ updateAmounts();
+}
+
+void LoanPaymentPage::slotAdditionalFees(void)
+{
+ QMap<QString, MyMoneyMoney> priceInfo;
+ KSplitTransactionDlg* dlg = new KSplitTransactionDlg(d->additionalFeesTransaction, d->phonySplit, d->phonyAccount, false, !m_wizard->moneyBorrowed(), MyMoneyMoney(0), priceInfo);
+
+ // connect(dlg, SIGNAL(newCategory(MyMoneyAccount&)), this, SIGNAL(newCategory(MyMoneyAccount&)));
+
+ if(dlg->exec() == QDialog::Accepted) {
+ d->additionalFeesTransaction = dlg->transaction();
+ // sum up the additional fees
+ QValueList<MyMoneySplit>::ConstIterator it;
+
+ d->additionalFees = MyMoneyMoney(0);
+ for(it = d->additionalFeesTransaction.splits().begin(); it != d->additionalFeesTransaction.splits().end(); ++it) {
+ if((*it).accountId() != d->phonyAccount.id()) {
+ d->additionalFees += (*it).shares();
+ }
+ }
+ updateAmounts();
+ }
+
+ delete dlg;
+}
+
+KMyMoneyWizardPage* LoanPaymentPage::nextPage(void) const
+{
+ return m_wizard->m_loanSchedulePage;
+}
+
+
+LoanSchedulePage::LoanSchedulePage(Wizard* wizard, const char* name) :
+ KLoanSchedulePageDecl(wizard),
+ WizardPage<Wizard>(StepSchedule, this, wizard, name)
+{
+ m_mandatoryGroup->add(m_interestCategory->lineEdit());
+ m_mandatoryGroup->add(m_paymentAccount->lineEdit());
+ connect(m_interestCategory, SIGNAL(createItem(const QString&, QString&)), this, SLOT(slotCreateCategory(const QString&, QString&)));
+ connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadWidgets()));
+}
+
+void LoanSchedulePage::slotCreateCategory(const QString& name, QString& id)
+{
+ MyMoneyAccount acc, parent;
+ acc.setName(name);
+
+ if(m_wizard->moneyBorrowed())
+ parent = MyMoneyFile::instance()->expense();
+ else
+ parent = MyMoneyFile::instance()->income();
+
+ emit m_wizard->createCategory(acc, parent);
+
+ // return id
+ id = acc.id();
+}
+
+QDate LoanSchedulePage::firstPaymentDueDate(void) const
+{
+ if(m_firstPaymentDueDate->isEnabled())
+ return m_firstPaymentDueDate->date();
+ return m_wizard->m_generalLoanInfoPage->m_firstPaymentDate->date();
+}
+
+void LoanSchedulePage::enterPage(void)
+{
+ m_interestCategory->setFocus();
+ m_firstPaymentDueDate->setDisabled(m_wizard->m_generalLoanInfoPage->recordAllPayments());
+ slotLoadWidgets();
+}
+
+void LoanSchedulePage::slotLoadWidgets(void)
+{
+ AccountSet set;
+ if(m_wizard->moneyBorrowed())
+ set.addAccountGroup(MyMoneyAccount::Expense);
+ else
+ set.addAccountGroup(MyMoneyAccount::Income);
+ set.load(m_interestCategory->selector());
+
+ set.clear();
+ set.addAccountGroup(MyMoneyAccount::Asset);
+ set.load(m_paymentAccount->selector());
+}
+
+KMyMoneyWizardPage* LoanSchedulePage::nextPage(void) const
+{
+ // if the balance widget of the general loan info page is enabled and
+ // the value is not zero, then the payout already happened and we don't
+ // aks for it.
+ if(m_wizard->openingBalance().isZero())
+ return m_wizard->m_loanPayoutPage;
+ return m_wizard->m_accountSummaryPage;
+}
+
+LoanPayoutPage::LoanPayoutPage(Wizard* wizard, const char* name) :
+ KLoanPayoutPageDecl(wizard),
+ WizardPage<Wizard>(StepPayout, this, wizard, name)
+{
+ m_mandatoryGroup->add(m_assetAccount->lineEdit());
+ m_mandatoryGroup->add(m_loanAccount->lineEdit());
+
+ KIconLoader* il = KGlobal::iconLoader();
+ KGuiItem createAssetButtenItem( i18n( "&Create..." ),
+ QIconSet(il->loadIcon("filenew", KIcon::Small, KIcon::SizeSmall)),
+ i18n("Create a new asset account"),
+ i18n("If the asset account does not yet exist, press this button to create it."));
+ m_createAssetButton->setGuiItem(createAssetButtenItem);
+ QToolTip::add(m_createAssetButton, createAssetButtenItem.toolTip());
+ QWhatsThis::add(m_createAssetButton, createAssetButtenItem.whatsThis());
+ connect(m_createAssetButton, SIGNAL(clicked()), this, SLOT(slotCreateAssetAccount()));
+
+ connect(m_noPayoutTransaction, SIGNAL(toggled(bool)), this, SLOT(slotButtonsToggled()));
+ connect(m_refinanceLoan, SIGNAL(toggled(bool)), this, SLOT(slotButtonsToggled()));
+
+ connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadWidgets()));
+ slotLoadWidgets();
+}
+
+void LoanPayoutPage::slotButtonsToggled(void)
+{
+ // we don't go directly, as the order of the emission of signals to slots is
+ // not defined. Using a single shot timer postpones the call of m_mandatoryGroup::changed()
+ // until the next round of the main loop so we can be sure to see all relevant changes
+ // that happened in the meantime (eg. widgets are enabled and disabled)
+ QTimer::singleShot(0, m_mandatoryGroup, SLOT(changed()));
+}
+
+void LoanPayoutPage::slotCreateAssetAccount(void)
+{
+ MyMoneyAccount acc;
+ acc.setAccountType(MyMoneyAccount::Asset);
+ acc.setOpeningDate(m_wizard->m_accountTypePage->m_openingDate->date());
+
+ emit m_wizard->createAccount(acc);
+
+ if(!acc.id().isEmpty()) {
+ m_assetAccount->setSelectedItem(acc.id());
+ }
+}
+
+void LoanPayoutPage::slotLoadWidgets(void)
+{
+ AccountSet set;
+ set.addAccountGroup(MyMoneyAccount::Asset);
+ set.load(m_assetAccount->selector());
+
+ set.clear();
+ set.addAccountType(MyMoneyAccount::Loan);
+ set.load(m_loanAccount->selector());
+}
+
+void LoanPayoutPage::enterPage(void)
+{
+ // only allow to create new asset accounts for liability loans
+ m_createAssetButton->setEnabled(m_wizard->moneyBorrowed());
+ m_refinanceLoan->setEnabled(m_wizard->moneyBorrowed());
+ if(!m_wizard->moneyBorrowed()) {
+ m_refinanceLoan->setChecked(false);
+ }
+ m_payoutDetailFrame->setDisabled(m_noPayoutTransaction->isChecked());
+}
+
+KMyMoneyWizardPage* LoanPayoutPage::nextPage(void) const
+{
+ return m_wizard->m_accountSummaryPage;
+}
+
+bool LoanPayoutPage::isComplete(void) const
+{
+ return KMyMoneyWizardPage::isComplete() | m_noPayoutTransaction->isChecked();
+}
+
+const QString& LoanPayoutPage::payoutAccountId(void) const
+{
+ if(m_refinanceLoan->isChecked()) {
+ return m_loanAccount->selectedItem();
+ } else {
+ return m_assetAccount->selectedItem();
+ }
+}
+
+HierarchyPage::HierarchyPage(Wizard* wizard, const char* name) :
+ KHierarchyPageDecl(wizard),
+ WizardPage<Wizard>(StepParentAccount, this, wizard, name)
+{
+ // the next line causes a warning to be shown in the console output
+ // since at least one of the major groups is selected, and the user
+ // cannot deselect an account, at least one is selected all the time
+ // and we don't need this check
+ // m_mandatoryGroup->add(m_qlistviewParentAccounts);
+ m_qlistviewParentAccounts->setEnabled(true);
+ m_qlistviewParentAccounts->setRootIsDecorated(true);
+ m_qlistviewParentAccounts->setAllColumnsShowFocus(true);
+ m_qlistviewParentAccounts->addColumn("Accounts");
+ m_qlistviewParentAccounts->setMultiSelection(false);
+ m_qlistviewParentAccounts->header()->setResizeEnabled(true);
+ m_qlistviewParentAccounts->setColumnWidthMode(0, QListView::Maximum);
+ // never show the horizontal scroll bar
+ // m_qlistviewParentAccounts->setHScrollBarMode(QScrollView::AlwaysOff);
+}
+
+void HierarchyPage::enterPage(void)
+{
+ // Ensure that the list reflects the Account Type
+ // - if the type has changed
+ // - - clear the list
+ // - - populate the account list (also occurs first time we come here)
+ MyMoneyAccount topAccount = m_wizard->m_accountTypePage->parentAccount();
+
+ // If the list was not populated with this top account we populate it now
+ if ( &m_topAccount == NULL || m_topAccount.id() != topAccount.id())
+ {
+ if ( &m_topAccount != NULL )
+ {
+ // If the list has alrady been populated clear it
+ if ( (*m_qlistviewParentAccounts).childCount() > 0 )
+ (*m_qlistviewParentAccounts).clear();
+ }
+
+ // Add the Tree for the Top Account
+ KMyMoneyAccountTreeItem *topAccountTree = buildAccountTree(m_qlistviewParentAccounts, topAccount, false);
+ topAccountTree->setOpen(true);
+ // Record the top account used to populate the list
+ m_topAccount = topAccount;
+ }
+}
+
+KMyMoneyAccountTreeItem* HierarchyPage::buildAccountTree
+ ( KMyMoneyAccountTreeBase* parent
+ , const MyMoneyAccount& account
+ , bool open ) const
+{
+ // Recursively add child accounts to the list
+ if ( account.accountType() == MyMoneyAccount::Investment)
+ return NULL;
+ KMyMoneyAccountTreeItem* childItem = new KMyMoneyAccountTreeItem( parent, account );
+ if ( open )
+ childItem->setOpen(true);
+ for ( QStringList::ConstIterator it = account.accountList().begin();
+ it != account.accountList().end();
+ ++it )
+ {
+ MyMoneyAccount acc = MyMoneyFile::instance()->account(*it);
+ if(acc.isClosed())
+ continue;
+ if(acc.accountType() == MyMoneyAccount::Investment)
+ continue;
+ buildAccountTree( childItem, acc, open );
+ }
+ return childItem;
+}
+
+KMyMoneyAccountTreeItem* HierarchyPage::buildAccountTree
+ ( KMyMoneyAccountTreeItem* parent
+ , const MyMoneyAccount& account
+ , bool open ) const
+{
+ // Recursively add child accounts to the list
+ if ( account.accountType() == MyMoneyAccount::Investment)
+ return NULL;
+ KMyMoneyAccountTreeItem* childItem = new KMyMoneyAccountTreeItem( parent, account );
+ if ( open )
+ childItem->setOpen(true);
+ for ( QStringList::ConstIterator it = account.accountList().begin();
+ it != account.accountList().end();
+ ++it )
+ {
+ MyMoneyAccount acc = MyMoneyFile::instance()->account(*it);
+ if(acc.isClosed())
+ continue;
+ if (account.accountType() == MyMoneyAccount::Investment)
+ continue;
+ buildAccountTree( childItem, acc, open );
+ }
+ return childItem;
+}
+
+KMyMoneyWizardPage* HierarchyPage::nextPage(void) const
+{
+ return m_wizard->m_accountSummaryPage;
+}
+
+const MyMoneyAccount& HierarchyPage::parentAccount(void)
+{
+ // TODO
+ // Instead of returning the Parent Account we can simply
+ // return the account associated with the current item
+ // in the ListView
+ KMyMoneyAccountTreeItem* item = dynamic_cast<KMyMoneyAccountTreeItem*>(m_qlistviewParentAccounts->currentItem());
+ return dynamic_cast<const MyMoneyAccount&>(item->itemObject());
+}
+
+AccountSummaryPage::AccountSummaryPage(Wizard* wizard, const char* name) :
+ KAccountSummaryPageDecl(wizard),
+ WizardPage<Wizard>(StepFinish, this, wizard, name)
+{
+ m_dataList->setSorting(-1);
+ m_dataList->setColumnWidthMode(1, QListView::Maximum);
+ m_dataList->setResizeMode(QListView::LastColumn);
+}
+
+void AccountSummaryPage::enterPage(void)
+{
+ MyMoneyAccount acc = m_wizard->account();
+ MyMoneySecurity sec = m_wizard->currency();
+ acc.fraction(sec);
+
+ // assign an id to the account inside the wizard which is required for a schedule
+ // get the schedule and clear the id again in the wizards object.
+ MyMoneyAccount tmp(QString("Phony-ID"), acc);
+ m_wizard->setAccount(tmp);
+ MyMoneySchedule sch = m_wizard->schedule();
+ m_wizard->setAccount(acc);
+
+ m_dataList->clear();
+
+ // Account data
+ QListViewItem* group = new KMyMoneyCheckListItem(m_dataList, i18n("Account information"), QString(), QString(), QCheckListItem::RadioButtonController);
+ group->setOpen(true);
+ QListViewItem* p;
+ p = new KListViewItem(group, i18n("Name"), acc.name());
+ if(!acc.isLoan())
+ p = new KListViewItem(group, p, i18n("Subaccount of"),
+ m_wizard->parentAccount().name());
+ if(acc.accountType() == MyMoneyAccount::AssetLoan)
+ p = new KListViewItem(group, p, i18n("Type"), i18n("Loan"));
+ else
+ p = new KListViewItem(group, p, i18n("Type"), m_wizard->m_accountTypePage->m_typeSelection->currentText());
+ p = new KListViewItem(group, p, i18n("Currency"), m_wizard->currency().name());
+ p = new KListViewItem(group, p, i18n("Opening date"), KGlobal::locale()->formatDate(acc.openingDate()));
+ if(m_wizard->currency().id() != MyMoneyFile::instance()->baseCurrency().id()) {
+ p = new KListViewItem(group, p, i18n("Conversion rate"), m_wizard->conversionRate().rate(QString()).formatMoney("", KMyMoneyGlobalSettings::pricePrecision()));
+ }
+ if(!acc.isLoan() || !m_wizard->openingBalance().isZero())
+ p = new KListViewItem(group, p, i18n("Opening balance"), m_wizard->openingBalance().formatMoney(acc, sec));
+
+ if(!m_wizard->m_institutionPage->institution().id().isEmpty()) {
+ p = new KListViewItem(group, p, i18n("Institution"), m_wizard->m_institutionPage->institution().name());
+ if(!acc.number().isEmpty()) {
+ p = new KListViewItem(group, p, i18n("Number"), acc.number());
+ }
+ if(!acc.value("IBAN").isEmpty()) {
+ p = new KListViewItem(group, p, i18n("IBAN"), acc.value("IBAN"));
+ }
+ }
+
+ if(acc.accountType() == MyMoneyAccount::Investment) {
+ if(m_wizard->m_brokeragepage->m_createBrokerageButton->isChecked()) {
+ group = new KMyMoneyCheckListItem(m_dataList, group, i18n("Brokerage Account"), QString(), QString(), QCheckListItem::RadioButtonController);
+ group->setOpen(true);
+ p = new KListViewItem(group, p, i18n("Name"), QString("%1 (Brokerage)").arg(acc.name()));
+ p = new KListViewItem(group, p, i18n("Currency"), m_wizard->m_brokeragepage->m_brokerageCurrency->security().name());
+ if(m_wizard->m_brokeragepage->m_accountNumber->isEnabled() && !m_wizard->m_brokeragepage->m_accountNumber->text().isEmpty())
+ p = new KListViewItem(group, p, i18n("Number"), m_wizard->m_brokeragepage->m_accountNumber->text());
+ if(m_wizard->m_brokeragepage->m_iban->isEnabled() && !m_wizard->m_brokeragepage->m_iban->text().isEmpty())
+ p = new KListViewItem(group, p, i18n("IBAN"), m_wizard->m_brokeragepage->m_iban->text());
+ }
+ }
+
+ // Loan
+ if(acc.isLoan()) {
+ group = new KMyMoneyCheckListItem(m_dataList, group, i18n("Loan information"), QString(), QString(), QCheckListItem::RadioButtonController);
+ group->setOpen(true);
+ if(m_wizard->moneyBorrowed()) {
+ p = new KListViewItem(group, p, i18n("Amount borrowed"), m_wizard->m_loanDetailsPage->m_loanAmount->value().formatMoney(m_wizard->currency().tradingSymbol(), m_wizard->precision()));
+ } else {
+ p = new KListViewItem(group, p, i18n("Amount lent"), m_wizard->m_loanDetailsPage->m_loanAmount->value().formatMoney(m_wizard->currency().tradingSymbol(), m_wizard->precision()));
+ }
+ p = new KListViewItem(group, p, i18n("Interest rate"), QString("%1 %").arg(m_wizard->m_loanDetailsPage->m_interestRate->value().formatMoney("", -1)));
+ p = new KListViewItem(group, p, i18n("Interest rate is"), m_wizard->m_generalLoanInfoPage->m_interestType->currentText());
+ p = new KListViewItem(group, p, i18n("Principal and interest"), m_wizard->m_loanDetailsPage->m_paymentAmount->value().formatMoney(acc, sec));
+ p = new KListViewItem(group, p, i18n("Additional fees"), m_wizard->m_loanPaymentPage->additionalFees().formatMoney(acc, sec));
+ p = new KListViewItem(group, p, i18n("Payment frequency"), m_wizard->m_generalLoanInfoPage->m_paymentFrequency->currentText());
+ p = new KListViewItem(group, p, i18n("Payment account"), m_wizard->m_loanSchedulePage->m_paymentAccount->currentText());
+
+ if(!m_wizard->m_loanPayoutPage->m_noPayoutTransaction->isChecked() && m_wizard->openingBalance().isZero()) {
+ group = new KMyMoneyCheckListItem(m_dataList, group, i18n("Payout information"), QString(), QString(), QCheckListItem::RadioButtonController);
+ group->setOpen(true);
+ if(m_wizard->m_loanPayoutPage->m_refinanceLoan->isChecked()) {
+ p = new KListViewItem(group, p, i18n("Refinance"), m_wizard->m_loanPayoutPage->m_loanAccount->currentText());
+ } else {
+ if(m_wizard->moneyBorrowed())
+ p = new KListViewItem(group, p, i18n("Transfer amount to"), m_wizard->m_loanPayoutPage->m_assetAccount->currentText());
+ else
+ p = new KListViewItem(group, p, i18n("Transfer amount from"), m_wizard->m_loanPayoutPage->m_assetAccount->currentText());
+ }
+ p = new KListViewItem(group, p, i18n("Payment date"), KGlobal::locale()->formatDate(m_wizard->m_loanPayoutPage->m_payoutDate->date()));
+ }
+ }
+
+ // Schedule
+ if(!(sch == MyMoneySchedule())) {
+ group = new KMyMoneyCheckListItem(m_dataList, group, i18n("Schedule information"), QString(), QString(), QCheckListItem::RadioButtonController);
+ group->setOpen(true);
+ p = new KListViewItem(group, i18n("Name"), sch.name());
+ if(acc.accountType() == MyMoneyAccount::CreditCard) {
+ MyMoneyAccount paymentAccount = MyMoneyFile::instance()->account(m_wizard->m_schedulePage->m_paymentAccount->selectedItem());
+ p = new KListViewItem(group, p, i18n("Occurence"), i18n("Monthly"));
+ p = new KListViewItem(group, p, i18n("Paid from"), paymentAccount.name());
+ p = new KListViewItem(group, p, i18n("Pay to"), m_wizard->m_schedulePage->m_payee->currentText());
+ p = new KListViewItem(group, p, i18n("Amount"), m_wizard->m_schedulePage->m_amount->value().formatMoney(acc, sec));
+ p = new KListViewItem(group, p, i18n("First payment due"), KGlobal::locale()->formatDate(sch.nextDueDate()));
+ p = new KListViewItem(group, p, i18n("Payment method"), m_wizard->m_schedulePage->m_method->currentText());
+ }
+ if(acc.isLoan()) {
+ p = new KListViewItem(group, p, i18n("Occurence"), m_wizard->m_generalLoanInfoPage->m_paymentFrequency->currentText());
+ p = new KListViewItem(group, p, i18n("Amount"), (m_wizard->m_loanPaymentPage->basePayment() + m_wizard->m_loanPaymentPage->additionalFees()).formatMoney(acc, sec));
+ p = new KListViewItem(group, p, i18n("First payment due"), KGlobal::locale()->formatDate(m_wizard->m_loanSchedulePage->firstPaymentDueDate()));
+ }
+ }
+}
+
+#include "knewaccountwizard.moc"