Added kmymoney

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kmymoney@1239792 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1094 insertions, 0 deletions

diff --git a/kmymoney2/dialogs/investtransactioneditor.cpp b/kmymoney2/dialogs/investtransactioneditor.cpp
new file mode 100644
index 0000000..5a62436
--- /dev/null
+++ b/kmymoney2/dialogs/investtransactioneditor.cpp
@@ -0,0 +1,1094 @@
+/***************************************************************************
+                             investtransactioneditor.cpp
+                             ----------
+    begin                : Fri Dec 15 2006
+    copyright            : (C) 2006 by 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 <typeinfo>
+
+// ----------------------------------------------------------------------------
+// QT Includes
+
+#include <qlabel.h>
+#include <qapplication.h>
+#include <qeventloop.h>
+#include <qradiobutton.h>
+#include <qbuttongroup.h>
+
+// ----------------------------------------------------------------------------
+// KDE Includes
+
+#include <ktextedit.h>
+#include <klocale.h>
+#include <kcombobox.h>
+#include <kpushbutton.h>
+#include <kmessagebox.h>
+#include <kstdguiitem.h>
+
+// ----------------------------------------------------------------------------
+// Project Includes
+
+#include <kmymoney/investtransactioneditor.h>
+#include <kmymoney/kmymoneycategory.h>
+#include <kmymoney/kmymoneydateinput.h>
+#include <kmymoney/kmymoneyedit.h>
+#include <kmymoney/kmymoneylineedit.h>
+#include <kmymoney/kmymoneyaccountcompletion.h>
+#include <kmymoney/kmymoneyaccountselector.h>
+#include <kmymoney/mymoneyfile.h>
+#include <kmymoney/transactionform.h>
+
+#include "../dialogs/ksplittransactiondlg.h"
+#include "../dialogs/kcurrencycalculator.h"
+
+#include "../kmymoneyglobalsettings.h"
+
+#include "investactivities.h"
+
+using namespace KMyMoneyRegister;
+using namespace KMyMoneyTransactionForm;
+using namespace Invest;
+
+class InvestTransactionEditor::Private {
+  friend class Invest::Activity;
+
+public:
+  Private(InvestTransactionEditor* parent) :
+    m_parent(parent),
+    m_activity(0)
+  {
+    m_phonyAccount = MyMoneyAccount("Phony-ID", MyMoneyAccount());
+  }
+
+  ~Private() {
+    delete m_activity;
+  }
+
+  QWidget* haveWidget(const QString& name) { return m_parent->haveWidget(name); }
+
+  InvestTransactionEditor* m_parent;
+  Activity*                m_activity;
+  MyMoneyAccount           m_phonyAccount;
+  MyMoneySplit             m_phonySplit;
+};
+
+
+InvestTransactionEditor::InvestTransactionEditor() :
+  d(new Private(this))
+{
+}
+
+InvestTransactionEditor::~InvestTransactionEditor()
+{
+  delete d;
+}
+
+InvestTransactionEditor::InvestTransactionEditor(TransactionEditorContainer* regForm, KMyMoneyRegister::InvestTransaction* item, const KMyMoneyRegister::SelectedTransactions& list, const QDate& lastPostDate) :
+  TransactionEditor(regForm, item, list, lastPostDate),
+  d(new Private(this))
+{
+  // dissect the transaction into its type, splits, currency, security etc.
+  dissectTransaction(m_transaction, m_split,
+                     m_assetAccountSplit,
+                     m_feeSplits,
+                     m_interestSplits,
+                     m_security,
+                     m_currency,
+                     m_transactionType);
+
+  // determine initial activity object
+  activityFactory(m_transactionType);
+}
+
+void InvestTransactionEditor::activityFactory(MyMoneySplit::investTransactionTypeE type)
+{
+  if(!d->m_activity || type != d->m_activity->type()) {
+    delete d->m_activity;
+    switch(type) {
+      default:
+      case MyMoneySplit::BuyShares:
+        d->m_activity = new Buy(this);
+        break;
+      case MyMoneySplit::SellShares:
+        d->m_activity = new Sell(this);
+        break;
+      case MyMoneySplit::Dividend:
+      case MyMoneySplit::Yield:
+        d->m_activity = new Div(this);
+        break;
+      case MyMoneySplit::ReinvestDividend:
+        d->m_activity = new Reinvest(this);
+        break;
+      case MyMoneySplit::AddShares:
+        d->m_activity = new Add(this);
+        break;
+      case MyMoneySplit::RemoveShares:
+        d->m_activity = new Remove(this);
+        break;
+      case MyMoneySplit::SplitShares:
+        d->m_activity = new Split(this);
+        break;
+    }
+  }
+}
+
+void InvestTransactionEditor::dissectTransaction(const MyMoneyTransaction& transaction, const MyMoneySplit& split, MyMoneySplit& assetAccountSplit, QValueList<MyMoneySplit>& feeSplits, QValueList<MyMoneySplit>& interestSplits, MyMoneySecurity& security, MyMoneySecurity& currency, MyMoneySplit::investTransactionTypeE& transactionType)
+{
+  // collect the splits. split references the stock account and should already
+  // be set up. assetAccountSplit references the corresponding asset account (maybe
+  // empty), feeSplits is the list of all expenses and interestSplits
+  // the list of all incomes
+  MyMoneyFile* file = MyMoneyFile::instance();
+  QValueList<MyMoneySplit>::ConstIterator it_s;
+  for(it_s = transaction.splits().begin(); it_s != transaction.splits().end(); ++it_s) {
+    MyMoneyAccount acc = file->account((*it_s).accountId());
+    if((*it_s).id() == split.id()) {
+      security = file->security(acc.currencyId());
+    } else if(acc.accountGroup() == MyMoneyAccount::Expense) {
+      feeSplits.append(*it_s);
+      // feeAmount += (*it_s).value();
+    } else if(acc.accountGroup() == MyMoneyAccount::Income) {
+      interestSplits.append(*it_s);
+      // interestAmount += (*it_s).value();
+    } else {
+      assetAccountSplit = *it_s;
+    }
+  }
+
+  // determine transaction type
+  if(split.action() == MyMoneySplit::ActionAddShares) {
+    transactionType = (!split.shares().isNegative()) ? MyMoneySplit::AddShares : MyMoneySplit::RemoveShares;
+  } else if(split.action() == MyMoneySplit::ActionBuyShares) {
+    transactionType = (!split.value().isNegative()) ? MyMoneySplit::BuyShares : MyMoneySplit::SellShares;
+  } else if(split.action() == MyMoneySplit::ActionDividend) {
+    transactionType = MyMoneySplit::Dividend;
+  } else if(split.action() == MyMoneySplit::ActionReinvestDividend) {
+    transactionType = MyMoneySplit::ReinvestDividend;
+  } else if(split.action() == MyMoneySplit::ActionYield) {
+    transactionType = MyMoneySplit::Yield;
+  } else if(split.action() == MyMoneySplit::ActionSplitShares) {
+    transactionType = MyMoneySplit::SplitShares;
+  } else
+    transactionType = MyMoneySplit::BuyShares;
+
+  currency.setTradingSymbol("???");
+  try {
+    currency = file->security(transaction.commodity());
+  } catch(MyMoneyException *e) {
+    delete e;
+  }
+}
+
+void InvestTransactionEditor::createEditWidgets(void)
+{
+  KMyMoneyActivityCombo* activity = new KMyMoneyActivityCombo();
+  m_editWidgets["activity"] = activity;
+  connect(activity, SIGNAL(activitySelected(MyMoneySplit::investTransactionTypeE)), this, SLOT(slotUpdateActivity(MyMoneySplit::investTransactionTypeE)));
+  connect(activity, SIGNAL(activitySelected(MyMoneySplit::investTransactionTypeE)), this, SLOT(slotUpdateButtonState()));
+
+  m_editWidgets["postdate"] = new kMyMoneyDateInput;
+  connect(m_editWidgets["postdate"], SIGNAL(dateChanged(const QDate&)), this, SLOT(slotUpdateButtonState()));
+
+  KMyMoneySecurity* security = new KMyMoneySecurity;
+  security->setHint(i18n("Security"));
+  m_editWidgets["security"] = security;
+  connect(security, SIGNAL(itemSelected(const QString&)), this, SLOT(slotUpdateSecurity(const QString&)));
+  connect(security, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(security, SIGNAL(createItem(const QString&, QString&)), this, SLOT(slotCreateSecurity(const QString&, QString&)));
+  connect(security, SIGNAL(objectCreation(bool)), this, SIGNAL(objectCreation(bool)));
+
+  KMyMoneyCategory* asset = new KMyMoneyCategory(0, 0, false);
+  asset->setHint(i18n("Asset account"));
+  m_editWidgets["asset-account"] = asset;
+  connect(asset, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(asset, SIGNAL(objectCreation(bool)), this, SIGNAL(objectCreation(bool)));
+
+  KMyMoneyCategory* fees = new KMyMoneyCategory(0, 0, true);
+  fees->setHint(i18n("Fees"));
+  m_editWidgets["fee-account"] = fees;
+  connect(fees, SIGNAL(itemSelected(const QString&)), this, SLOT(slotUpdateFeeCategory(const QString&)));
+  connect(fees, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(fees, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateFeeVisibility(const QString&)));
+  connect(fees, SIGNAL(createItem(const QString&, QString&)), this, SLOT(slotCreateFeeCategory(const QString&, QString&)));
+  connect(fees, SIGNAL(objectCreation(bool)), this, SIGNAL(objectCreation(bool)));
+  connect(fees->splitButton(), SIGNAL(clicked()), this, SLOT(slotEditFeeSplits()));
+
+  KMyMoneyCategory* interest = new KMyMoneyCategory(0, 0, true);
+  interest->setHint(i18n("Interest"));
+  m_editWidgets["interest-account"] = interest;
+  connect(interest, SIGNAL(itemSelected(const QString&)), this, SLOT(slotUpdateInterestCategory(const QString&)));
+  connect(interest, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(interest, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateInterestVisibility(const QString&)));
+  connect(interest, SIGNAL(createItem(const QString&, QString&)), this, SLOT(slotCreateInterestCategory(const QString&, QString&)));
+  connect(interest, SIGNAL(objectCreation(bool)), this, SIGNAL(objectCreation(bool)));
+  connect(interest->splitButton(), SIGNAL(clicked()), this, SLOT(slotEditInterestSplits()));
+
+  KTextEdit* memo = new KTextEdit;
+  memo->setTabChangesFocus(true);
+  m_editWidgets["memo"] = memo;
+
+  kMyMoneyEdit* value = new kMyMoneyEdit;
+  value->setHint(i18n("Shares"));
+  value->setResetButtonVisible(false);
+  m_editWidgets["shares"] = value;
+  connect(value, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(value, SIGNAL(valueChanged(const QString&)), this, SLOT(slotUpdateTotalAmount()));
+
+  value = new kMyMoneyEdit;
+  value->setHint(i18n("Price"));
+  value->setResetButtonVisible(false);
+  value->setPrecision(KMyMoneyGlobalSettings::pricePrecision());
+  m_editWidgets["price"] = value;
+  connect(value, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(value, SIGNAL(valueChanged(const QString&)), this, SLOT(slotUpdateTotalAmount()));
+
+  value = new kMyMoneyEdit;
+  // TODO once we have the selected transactions as array of Transaction
+  // we can allow multiple splits for fee and interest
+  value->setResetButtonVisible(false);
+  m_editWidgets["fee-amount"] = value;
+  connect(value, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(value, SIGNAL(valueChanged(const QString&)), this, SLOT(slotUpdateTotalAmount()));
+
+  value = new kMyMoneyEdit;
+  // TODO once we have the selected transactions as array of Transaction
+  // we can allow multiple splits for fee and interest
+  value->setResetButtonVisible(false);
+  m_editWidgets["interest-amount"] = value;
+  connect(value, SIGNAL(textChanged(const QString&)), this, SLOT(slotUpdateButtonState()));
+  connect(value, SIGNAL(valueChanged(const QString&)), this, SLOT(slotUpdateTotalAmount()));
+
+  KMyMoneyReconcileCombo* reconcile = new KMyMoneyReconcileCombo;
+  m_editWidgets["status"] = reconcile;
+  connect(reconcile, SIGNAL(itemSelected(const QString&)), this, SLOT(slotUpdateButtonState()));
+
+  KMyMoneyRegister::QWidgetContainer::iterator it_w;
+  for(it_w = m_editWidgets.begin(); it_w != m_editWidgets.end(); ++it_w) {
+    (*it_w)->installEventFilter(this);
+  }
+
+  QLabel* label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::AlignRight | Qt::DontClip);
+  m_editWidgets["total"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["total-label"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["asset-label"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["fee-label"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["fee-amount-label"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["interest-label"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["interest-amount-label"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["price-label"] = label;
+
+  label = new QLabel("", 0);
+  label->setAlignment(Qt::AlignVCenter | Qt::DontClip);
+  m_editWidgets["shares-label"] = label;
+
+  // if we don't have more than 1 selected transaction, we don't need
+  // the "don't change" item in some of the combo widgets
+  if(m_transactions.count() < 2) {
+    reconcile->removeDontCare();
+  }
+}
+
+int InvestTransactionEditor::slotEditFeeSplits(void)
+{
+  return editSplits("fee-account", "fee-amount", m_feeSplits, false, SLOT(slotEditFeeSplits()));
+}
+
+int InvestTransactionEditor::slotEditInterestSplits(void)
+{
+  return editSplits("interest-account", "interest-amount", m_interestSplits, true, SLOT(slotEditInterestSplits()));
+}
+
+int InvestTransactionEditor::editSplits(const QString& categoryWidgetName, const QString& amountWidgetName, QValueList<MyMoneySplit>& splits, bool isIncome, const char* slotEditSplits)
+{
+  int rc = QDialog::Rejected;
+
+  if(!m_openEditSplits) {
+  // only get in here in a single instance
+    m_openEditSplits = true;
+
+    // force focus change to update all data
+    KMyMoneyCategory* category = dynamic_cast<KMyMoneyCategory*>(m_editWidgets[categoryWidgetName]);
+    QWidget* w = category->splitButton();
+    if(w)
+      w->setFocus();
+
+    kMyMoneyEdit* amount = dynamic_cast<kMyMoneyEdit*>(haveWidget(amountWidgetName));
+
+    MyMoneyTransaction transaction;
+    transaction.setCommodity(m_currency.id());
+    if(splits.count() == 0 && category->selectedItem()) {
+      MyMoneySplit s;
+      s.setAccountId(category->selectedItem());
+      s.setShares(amount->value());
+      s.setValue(s.shares());
+      splits << s;
+    }
+    // use the transactions commodity as the currency indicator for the splits
+    // this is used to allow some useful setting for the fractions in the amount fields
+    try {
+      d->m_phonyAccount.setCurrencyId(m_transaction.commodity());
+      d->m_phonyAccount.fraction(MyMoneyFile::instance()->security(m_transaction.commodity()));
+    } catch(MyMoneyException *e) {
+      qDebug("Unable to setup precision");
+      delete e;
+    }
+
+    if(createPseudoTransaction(transaction, splits)) {
+      MyMoneyMoney value;
+
+      KSplitTransactionDlg* dlg = new KSplitTransactionDlg(transaction,
+                                                          d->m_phonySplit,
+                                                          d->m_phonyAccount,
+                                                          false,
+                                                          isIncome,
+                                                          0,
+                                                          m_priceInfo,
+                                                          m_regForm);
+      // connect(dlg, SIGNAL(newCategory(MyMoneyAccount&)), this, SIGNAL(newCategory(MyMoneyAccount&)));
+
+      if((rc = dlg->exec()) == QDialog::Accepted) {
+        transaction = dlg->transaction();
+        // collect splits out of the transaction
+        splits.clear();
+        QValueList<MyMoneySplit>::const_iterator it_s;
+        MyMoneyMoney fees;
+        for(it_s = transaction.splits().begin(); it_s != transaction.splits().end(); ++it_s) {
+          if((*it_s).accountId() == d->m_phonyAccount.id())
+            continue;
+          splits << *it_s;
+          fees += (*it_s).shares();
+        }
+        if(isIncome)
+          fees = -fees;
+
+        QString categoryId;
+        setupCategoryWidget(category, splits, categoryId, slotEditSplits);
+        amount->setValue(fees);
+        slotUpdateTotalAmount();
+      }
+
+      delete dlg;
+    }
+
+    // focus jumps into the memo field
+    if((w = haveWidget("memo")) != 0) {
+      w->setFocus();
+    }
+
+    m_openEditSplits = false;
+  }
+  return rc;
+}
+
+bool InvestTransactionEditor::createPseudoTransaction(MyMoneyTransaction& t, const QValueList<MyMoneySplit>& splits)
+{
+  t.removeSplits();
+
+  MyMoneySplit split;
+  split.setAccountId(d->m_phonyAccount.id());
+  split.setValue(-subtotal(splits));
+  split.setShares(split.value());
+  t.addSplit(split);
+  d->m_phonySplit = split;
+
+  QValueList<MyMoneySplit>::const_iterator it_s;
+  for(it_s = splits.begin(); it_s != splits.end(); ++it_s) {
+    split = *it_s;
+    split.clearId();
+    t.addSplit(split);
+  }
+  return true;
+}
+
+void InvestTransactionEditor::slotCreateSecurity(const QString& name, QString& id)
+{
+  MyMoneyAccount acc;
+  QRegExp exp("([^:]+)");
+  if(exp.search(name) != -1) {
+    acc.setName(exp.cap(1));
+
+    emit createSecurity(acc, m_account);
+
+    // return id
+    id = acc.id();
+
+    if(!id.isEmpty()) {
+      slotUpdateSecurity(id);
+    }
+  }
+}
+
+void InvestTransactionEditor::slotCreateFeeCategory(const QString& name, QString& id)
+{
+  MyMoneyAccount acc;
+  acc.setName(name);
+
+  emit createCategory(acc, MyMoneyFile::instance()->expense());
+
+  // return id
+  id = acc.id();
+}
+
+void InvestTransactionEditor::slotUpdateFeeCategory(const QString& id)
+{
+  haveWidget("fee-amount")->setDisabled(id.isEmpty());
+}
+
+void InvestTransactionEditor::slotUpdateFeeVisibility(const QString& txt)
+{
+  haveWidget("fee-amount")->setHidden(txt.isEmpty());
+  QWidget* w = haveWidget("fee-amount-label");
+  if(w)
+    w->setShown(haveWidget("fee-amount")->isVisible());
+}
+
+void InvestTransactionEditor::slotUpdateInterestCategory(const QString& id)
+{
+  haveWidget("interest-amount")->setDisabled(id.isEmpty());
+}
+
+void InvestTransactionEditor::slotUpdateInterestVisibility(const QString& txt)
+{
+  KMyMoneyCategory* interest = dynamic_cast<KMyMoneyCategory*>(haveWidget("interest-account"));
+  QWidget* w = haveWidget("interest-amount-label");
+
+  if(dynamic_cast<Reinvest*>(d->m_activity)) {
+    interest->splitButton()->hide();
+    haveWidget("interest-amount")->setHidden(true);
+    // for the reinvest case, we don't ever hide the label do avoid a shine through
+    // of the underlying transaction data.
+    w = 0;
+  } else {
+    haveWidget("interest-amount")->setHidden(txt.isEmpty());
+    // FIXME once we can handle split interest, we need to uncomment the next line
+    // interest->splitButton()->show();
+  }
+
+  if(w)
+    w->setShown(haveWidget("interest-amount")->isVisible());
+}
+
+void InvestTransactionEditor::slotCreateInterestCategory(const QString& name, QString& id)
+{
+  MyMoneyAccount acc;
+  acc.setName(name);
+
+  emit createCategory(acc, MyMoneyFile::instance()->income());
+
+  // return id
+  id = acc.id();
+}
+
+void InvestTransactionEditor::slotReloadEditWidgets(void)
+{
+  KMyMoneyCategory* interest = dynamic_cast<KMyMoneyCategory*>(haveWidget("interest-account"));
+  KMyMoneyCategory* fees = dynamic_cast<KMyMoneyCategory*>(haveWidget("fee-account"));
+  KMyMoneySecurity* security = dynamic_cast<KMyMoneySecurity*>(haveWidget("security"));
+
+  AccountSet aSet;
+  QString id;
+
+  // interest-account
+  aSet.clear();
+  aSet.addAccountGroup(MyMoneyAccount::Income);
+  aSet.load(interest->selector());
+  setupCategoryWidget(interest, m_interestSplits, id, SLOT(slotEditInterestSplits()));
+
+  // fee-account
+  aSet.clear();
+  aSet.addAccountGroup(MyMoneyAccount::Expense);
+  aSet.load(fees->selector());
+  setupCategoryWidget(fees, m_feeSplits, id, SLOT(slotEditFeeSplits()));
+
+  // security
+  aSet.clear();
+  aSet.load(security->selector(), i18n("Security"), m_account.accountList(), true);
+}
+
+void InvestTransactionEditor::loadEditWidgets(KMyMoneyRegister::Action /* action */)
+{
+  QString id;
+
+  kMyMoneyDateInput* postDate = dynamic_cast<kMyMoneyDateInput*>(haveWidget("postdate"));
+  KMyMoneyReconcileCombo* reconcile = dynamic_cast<KMyMoneyReconcileCombo*>(haveWidget("status"));
+  KMyMoneySecurity* security = dynamic_cast<KMyMoneySecurity*>(haveWidget("security"));
+  KMyMoneyActivityCombo* activity = dynamic_cast<KMyMoneyActivityCombo*>(haveWidget("activity"));
+  KMyMoneyCategory* asset = dynamic_cast<KMyMoneyCategory*>(haveWidget("asset-account"));
+  KTextEdit* memo = dynamic_cast<KTextEdit*>(m_editWidgets["memo"]);
+  kMyMoneyEdit* value;
+  KMyMoneyCategory* interest = dynamic_cast<KMyMoneyCategory*>(haveWidget("interest-account"));
+  KMyMoneyCategory* fees = dynamic_cast<KMyMoneyCategory*>(haveWidget("fee-account"));
+
+  // check if the current transaction has a reference to an equity account
+  bool haveEquityAccount = false;
+  QValueList<MyMoneySplit>::const_iterator it_s;
+  for(it_s = m_transaction.splits().begin(); !haveEquityAccount && it_s != m_transaction.splits().end(); ++it_s) {
+    MyMoneyAccount acc = MyMoneyFile::instance()->account((*it_s).accountId());
+    if(acc.accountType() == MyMoneyAccount::Equity)
+      haveEquityAccount = true;
+  }
+
+  // asset-account
+  AccountSet aSet;
+  aSet.clear();
+  aSet.addAccountType(MyMoneyAccount::Checkings);
+  aSet.addAccountType(MyMoneyAccount::Savings);
+  aSet.addAccountType(MyMoneyAccount::Cash);
+  aSet.addAccountType(MyMoneyAccount::Asset);
+  aSet.addAccountType(MyMoneyAccount::Currency);
+  aSet.addAccountType(MyMoneyAccount::CreditCard);
+  if(KMyMoneyGlobalSettings::expertMode() || haveEquityAccount)
+    aSet.addAccountGroup(MyMoneyAccount::Equity);
+  aSet.load(asset->selector());
+
+  // security
+  security->setSuppressObjectCreation(false);    // allow object creation on the fly
+  aSet.clear();
+  aSet.load(security->selector(), i18n("Security"), m_account.accountList(), true);
+
+  if(!isMultiSelection()) {
+    // date
+    if(m_transaction.postDate().isValid())
+      postDate->setDate(m_transaction.postDate());
+    else if(m_lastPostDate.isValid())
+      postDate->setDate(m_lastPostDate);
+    else
+      postDate->setDate(QDate::currentDate());
+
+    // security (but only if it's not the investment account)
+    if(m_split.accountId() != m_account.id()) {
+      security->completion()->setSelected(m_split.accountId());
+      security->slotItemSelected(m_split.accountId());
+    }
+
+    // activity
+    activity->setActivity(d->m_activity->type());
+    slotUpdateActivity(activity->activity());
+
+    asset->completion()->setSelected(m_assetAccountSplit.accountId());
+    asset->slotItemSelected(m_assetAccountSplit.accountId());
+
+    // interest-account
+    aSet.clear();
+    aSet.addAccountGroup(MyMoneyAccount::Income);
+    aSet.load(interest->selector());
+    setupCategoryWidget(interest, m_interestSplits, id, SLOT(slotEditInterestSplits()));
+    slotUpdateInterestVisibility(interest->currentText());
+
+    // fee-account
+    aSet.clear();
+    aSet.addAccountGroup(MyMoneyAccount::Expense);
+    aSet.load(fees->selector());
+    setupCategoryWidget(fees, m_feeSplits, id, SLOT(slotEditFeeSplits()));
+    slotUpdateFeeVisibility(fees->currentText());
+
+    // memo
+    memo->setText(m_split.memo());
+
+    // shares
+    // don't set the value if the number of shares is zero so that
+    // we can see the hint
+    value = dynamic_cast<kMyMoneyEdit*>(haveWidget("shares"));
+    if(typeid(*(d->m_activity)) != typeid(Invest::Split(this)))
+      value->setPrecision(MyMoneyMoney::denomToPrec(m_security.smallestAccountFraction()));
+    else
+      value->setPrecision(-1);
+
+    if(!m_split.shares().isZero())
+      value->setValue(m_split.shares().abs());
+
+    // price
+    updatePriceMode(m_split);
+
+    // fee amount
+    value = dynamic_cast<kMyMoneyEdit*>(haveWidget("fee-amount"));
+    value->setValue(subtotal(m_feeSplits));
+
+    // interest amount
+    value = dynamic_cast<kMyMoneyEdit*>(haveWidget("interest-amount"));
+    value->setValue(-subtotal(m_interestSplits));
+
+    // total
+    slotUpdateTotalAmount();
+
+    // status
+    if(m_split.reconcileFlag() == MyMoneySplit::Unknown)
+      m_split.setReconcileFlag(MyMoneySplit::NotReconciled);
+    reconcile->setState(m_split.reconcileFlag());
+
+  } else {
+    postDate->loadDate(QDate());
+    reconcile->setState(MyMoneySplit::Unknown);
+    memo->setText(QString());
+
+    // We don't allow to change the activity
+    activity->setActivity(d->m_activity->type());
+    slotUpdateActivity(activity->activity());
+    activity->setDisabled(true);
+
+    // scan the list of selected transactions and check that they have
+    // the same activity.
+    KMyMoneyRegister::SelectedTransactions::iterator it_t = m_transactions.begin();
+    const QString& action = m_item->split().action();
+    bool isNegative = m_item->split().shares().isNegative();
+    bool allSameActivity = true;
+    for(it_t = m_transactions.begin(); allSameActivity && (it_t != m_transactions.end()); ++it_t) {
+      allSameActivity = (action == (*it_t).split().action() && (*it_t).split().shares().isNegative() == isNegative);
+    }
+
+    QStringList fields;
+    fields << "shares" << "price" << "fee-amount" << "interest-amount";
+    QStringList::const_iterator it_f;
+    for(it_f = fields.begin(); it_f != fields.end(); ++it_f) {
+      value = dynamic_cast<kMyMoneyEdit*>(haveWidget((*it_f)));
+      value->setText("");
+      value->setAllowEmpty();
+    }
+
+    // if we have transactions with different activities, disable some more widgets
+    if(!allSameActivity) {
+      fields << "asset-account" << "fee-account" << "interest-account";
+      QStringList::const_iterator it_f;
+      for(it_f = fields.begin(); it_f != fields.end(); ++it_f) {
+        haveWidget(*it_f)->setDisabled(true);
+      }
+    }
+  }
+}
+
+QWidget* InvestTransactionEditor::firstWidget(void) const
+{
+  return 0; // let the creator use the first widget in the tab order
+}
+
+bool InvestTransactionEditor::isComplete(QString& reason) const
+{
+  reason = QString();
+  // reason.clear();  // for Qt4
+  return d->m_activity->isComplete(reason);
+}
+
+MyMoneyMoney InvestTransactionEditor::subtotal(const QValueList<MyMoneySplit>& splits) const
+{
+  QValueList<MyMoneySplit>::const_iterator it_s;
+  MyMoneyMoney sum;
+
+  for(it_s = splits.begin(); it_s != splits.end(); ++it_s) {
+    sum += (*it_s).value();
+  }
+
+  return sum;
+}
+
+void InvestTransactionEditor::slotUpdateSecurity(const QString& stockId)
+{
+  MyMoneyFile* file = MyMoneyFile::instance();
+  MyMoneyAccount stock = file->account(stockId);
+  m_security = file->security(stock.currencyId());
+  m_currency = file->security(m_security.tradingCurrency());
+  bool currencyKnown = !m_currency.id().isEmpty();
+  if(!currencyKnown) {
+    m_currency.setTradingSymbol("???");
+  } else {
+    if(typeid(*(d->m_activity)) != typeid(Invest::Split(this))) {
+      dynamic_cast<kMyMoneyEdit*>(haveWidget("shares"))->setPrecision(MyMoneyMoney::denomToPrec(m_security.smallestAccountFraction()));
+    } else {
+      dynamic_cast<kMyMoneyEdit*>(haveWidget("shares"))->setPrecision(-1);
+    }
+  }
+
+  updatePriceMode();
+
+  d->m_activity->preloadAssetAccount();
+
+  haveWidget("shares")->setEnabled(currencyKnown);
+  haveWidget("price")->setEnabled(currencyKnown);
+  haveWidget("fee-amount")->setEnabled(currencyKnown);
+  haveWidget("interest-amount")->setEnabled(currencyKnown);
+
+  slotUpdateTotalAmount();
+}
+
+void InvestTransactionEditor::totalAmount(MyMoneyMoney& amount) const
+{
+  KMyMoneyActivityCombo* activityCombo = dynamic_cast<KMyMoneyActivityCombo*>(haveWidget("activity"));
+  kMyMoneyEdit* sharesEdit = dynamic_cast<kMyMoneyEdit*>(haveWidget("shares"));
+  kMyMoneyEdit* priceEdit = dynamic_cast<kMyMoneyEdit*>(haveWidget("price"));
+  kMyMoneyEdit* feesEdit = dynamic_cast<kMyMoneyEdit*>(haveWidget("fee-amount"));
+  kMyMoneyEdit* interestEdit = dynamic_cast<kMyMoneyEdit*>(haveWidget("interest-amount"));
+
+  if(priceMode() == InvestTransactionEditor::PricePerTransaction)
+    amount = priceEdit->value().abs();
+  else
+    amount = sharesEdit->value().abs() * priceEdit->value().abs();
+
+  if(feesEdit->isVisible()) {
+    MyMoneyMoney fee = feesEdit->value();
+    MyMoneyMoney factor(-1,1);
+    switch(activityCombo->activity()) {
+      case MyMoneySplit::BuyShares:
+      case MyMoneySplit::ReinvestDividend:
+        factor = MyMoneyMoney(1,1);
+        break;
+      default:
+        break;
+    }
+    amount += (fee * factor);
+  }
+
+  if(interestEdit->isVisible()) {
+    MyMoneyMoney interest = interestEdit->value();
+    MyMoneyMoney factor(1,1);
+    switch(activityCombo->activity()) {
+      case MyMoneySplit::BuyShares:
+        factor = MyMoneyMoney(-1,1);
+        break;
+      default:
+        break;
+    }
+    amount += (interest * factor);
+  }
+}
+
+void InvestTransactionEditor::slotUpdateTotalAmount(void)
+{
+  QLabel* total = dynamic_cast<QLabel*>(haveWidget("total"));
+
+  if(total && total->isVisible()) {
+    MyMoneyMoney amount;
+    totalAmount(amount);
+    total->setText(amount.formatMoney(m_currency.tradingSymbol(), MyMoneyMoney::denomToPrec(m_security.smallestAccountFraction())));
+  }
+}
+
+void InvestTransactionEditor::slotUpdateActivity(MyMoneySplit::investTransactionTypeE activity)
+{
+  // create new activity object if required
+  activityFactory(activity);
+
+  KMyMoneyCategory* cat;
+
+  // hide all dynamic widgets (make sure to use the parentWidget for the
+  // category widgets)
+  haveWidget("interest-account")->parentWidget()->hide();
+  haveWidget("fee-account")->parentWidget()->hide();
+
+  QStringList dynwidgets;
+  dynwidgets << "total-label" << "asset-label" << "fee-label" << "fee-amount-label" << "interest-label" << "interest-amount-label" << "price-label" << "shares-label";
+
+  // hiding labels works by clearing them. hide() does not do the job
+  // as the underlying text in the QTable object will shine through
+  QStringList::const_iterator it_s;
+  for(it_s = dynwidgets.begin(); it_s != dynwidgets.end(); ++it_s) {
+    QLabel* w = dynamic_cast<QLabel*>(haveWidget(*it_s));
+    if(w)
+      w->setText(" ");
+  }
+
+  // real widgets can be hidden
+  dynwidgets.clear();
+  dynwidgets << "asset-account" << "interest-amount" << "fee-amount" << "shares" << "price" << "total";
+
+  for(it_s = dynwidgets.begin(); it_s != dynwidgets.end(); ++it_s) {
+    QWidget* w = haveWidget(*it_s);
+    if(w)
+      w->hide();
+  }
+
+  d->m_activity->showWidgets();
+
+  d->m_activity->preloadAssetAccount();
+
+  cat = dynamic_cast<KMyMoneyCategory*>(haveWidget("interest-account"));
+  if(cat->parentWidget()->isVisible())
+    slotUpdateInterestVisibility(cat->currentText());
+
+  cat = dynamic_cast<KMyMoneyCategory*>(haveWidget("fee-account"));
+  if(cat->parentWidget()->isVisible())
+    slotUpdateFeeVisibility(cat->currentText());
+}
+
+InvestTransactionEditor::priceModeE InvestTransactionEditor::priceMode(void) const
+{
+  priceModeE mode = static_cast<priceModeE>(0);
+  KMyMoneySecurity* sec = dynamic_cast<KMyMoneySecurity*>(m_editWidgets["security"]);
+  QString accId;
+  if(!sec->currentText().isEmpty()) {
+    accId = sec->selectedItem();
+    if(accId.isEmpty())
+      accId = m_account.id();
+  }
+  while(!accId.isEmpty() && mode == 0) {
+    MyMoneyAccount acc = MyMoneyFile::instance()->account(accId);
+    if(acc.value("priceMode").isEmpty())
+      accId = acc.parentAccountId();
+    else
+      mode = static_cast<priceModeE>(acc.value("priceMode").toInt());
+  }
+
+  // if it's still <default> then use that default
+  if(mode == 0)
+    mode = PricePerShare;
+  return mode;
+}
+
+bool InvestTransactionEditor::setupPrice(const MyMoneyTransaction& t, MyMoneySplit& split)
+{
+  MyMoneyFile* file = MyMoneyFile::instance();
+  MyMoneyAccount acc = file->account(split.accountId());
+  MyMoneySecurity toCurrency(file->security(acc.currencyId()));
+  int fract = acc.fraction();
+
+  if(acc.currencyId() != t.commodity()) {
+    QMap<QString, MyMoneyMoney>::Iterator it_p;
+    QString key = t.commodity() + "-" + acc.currencyId();
+    it_p = m_priceInfo.find(key);
+
+    // if it's not found, then collect it from the user first
+    MyMoneyMoney price;
+    if(it_p == m_priceInfo.end()) {
+      MyMoneySecurity fromCurrency = file->security(t.commodity());
+      MyMoneyMoney fromValue, toValue;
+
+      fromValue = split.value();
+      MyMoneyPrice priceInfo = MyMoneyFile::instance()->price(fromCurrency.id(), toCurrency.id());
+      toValue = split.value() * priceInfo.rate(toCurrency.id());
+
+      KCurrencyCalculator calc(fromCurrency,
+                                toCurrency,
+                                fromValue,
+                                toValue,
+                                t.postDate(),
+                                fract,
+                                m_regForm, "currencyCalculator");
+
+      if(calc.exec() == QDialog::Rejected) {
+        return false;
+      }
+      price = calc.price();
+      m_priceInfo[key] = price;
+    } else {
+      price = (*it_p);
+    }
+
+    // update shares if the transaction commodity is the currency
+    // of the current selected account
+    split.setShares((split.value() * price).convert(fract));
+  } else {
+    split.setShares(split.value().convert(fract));
+  }
+
+  return true;
+}
+
+bool InvestTransactionEditor::createTransaction(MyMoneyTransaction& t, const MyMoneyTransaction& torig, const MyMoneySplit& sorig, bool /* skipPriceDialog */)
+{
+  MyMoneyFile* file = MyMoneyFile::instance();
+  // we start with the previous values, make sure we can add them later on
+  t = torig;
+  MyMoneySplit s0 = sorig;
+  s0.clearId();
+
+  KMyMoneySecurity* sec = dynamic_cast<KMyMoneySecurity*>(m_editWidgets["security"]);
+  if(!isMultiSelection() || (isMultiSelection() && !sec->currentText().isEmpty())) {
+    QString securityId = sec->selectedItem();
+    if(!securityId.isEmpty()) {
+      s0.setAccountId(securityId);
+      MyMoneyAccount stockAccount = file->account(securityId);
+      QString currencyId = stockAccount.currencyId();
+      MyMoneySecurity security = file->security(currencyId);
+
+      t.setCommodity(security.tradingCurrency());
+    } else {
+      s0.setAccountId(m_account.id());
+      t.setCommodity(m_account.currencyId());
+    }
+  }
+
+  // extract price info from original transaction
+  m_priceInfo.clear();
+  QValueList<MyMoneySplit>::const_iterator it_s;
+  if(!torig.id().isEmpty()) {
+    for(it_s = torig.splits().begin(); it_s != torig.splits().end(); ++it_s) {
+      if((*it_s).id() != sorig.id()) {
+        MyMoneyAccount cat = file->account((*it_s).accountId());
+        if(cat.currencyId() != m_account.currencyId()) {
+          if(!(*it_s).shares().isZero() && !(*it_s).value().isZero()) {
+            m_priceInfo[cat.currencyId()] = ((*it_s).shares() / (*it_s).value()).reduce();
+          }
+        }
+      }
+    }
+  }
+
+  t.removeSplits();
+
+  kMyMoneyDateInput* postDate = dynamic_cast<kMyMoneyDateInput*>(m_editWidgets["postdate"]);
+  if(postDate->date().isValid()) {
+    t.setPostDate(postDate->date());
+  }
+
+  // memo and number field are special: if we have multiple transactions selected
+  // and the edit field is empty, we treat it as "not modified".
+  // FIXME a better approach would be to have a 'dirty' flag with the widgets
+  //       which identifies if the originally loaded value has been modified
+  //       by the user
+  KTextEdit* memo = dynamic_cast<KTextEdit*>(m_editWidgets["memo"]);
+  if(memo) {
+    if(!isMultiSelection() || (isMultiSelection() && !memo->text().isEmpty() ) )
+      s0.setMemo(memo->text());
+  }
+
+  MyMoneySplit assetAccountSplit;
+  QValueList<MyMoneySplit> feeSplits;
+  QValueList<MyMoneySplit> interestSplits;
+  MyMoneySecurity security, currency;
+  MyMoneySplit::investTransactionTypeE transactionType;
+
+  // extract the splits from the original transaction
+  dissectTransaction(torig, sorig,
+                     assetAccountSplit,
+                     feeSplits,
+                     interestSplits,
+                     security,
+                     currency,
+                     transactionType);
+
+  // check if the trading currency is the same if the security has changed
+  // in case it differs, check that we have a price (request from user)
+  // and convert all splits
+  // TODO
+
+  // do the conversions here
+  // TODO
+
+  // keep the current activity object and create a new one
+  // that can be destroyed later on
+  Activity* activity = d->m_activity;
+  d->m_activity = 0;      // make sure we create a new one
+  activityFactory(activity->type());
+
+  // if the activity is not set in the combo widget, we keep
+  // the one which is used in the original transaction
+  KMyMoneyActivityCombo* activityCombo = dynamic_cast<KMyMoneyActivityCombo*>(haveWidget("activity"));
+  if(activityCombo->activity() == MyMoneySplit::UnknownTransactionType) {
+    activityFactory(transactionType);
+  }
+
+  // if we mark the split reconciled here, we'll use today's date if no reconciliation date is given
+  KMyMoneyReconcileCombo* status = dynamic_cast<KMyMoneyReconcileCombo*>(m_editWidgets["status"]);
+  if(status->state() != MyMoneySplit::Unknown)
+    s0.setReconcileFlag(status->state());
+
+  if(s0.reconcileFlag() == MyMoneySplit::Reconciled && !s0.reconcileDate().isValid())
+    s0.setReconcileDate(QDate::currentDate());
+
+  // call the creation logic for the current selected activity
+  bool rc = d->m_activity->createTransaction(t, s0, assetAccountSplit, feeSplits, m_feeSplits, interestSplits, m_interestSplits, security, currency);
+
+  // now switch back to the original activity
+  delete d->m_activity;
+  d->m_activity = activity;
+
+  // add the splits to the transaction
+  if(rc) {
+    if(!assetAccountSplit.accountId().isEmpty()) {
+      assetAccountSplit.clearId();
+      t.addSplit(assetAccountSplit);
+    }
+
+    t.addSplit(s0);
+
+    QValueList<MyMoneySplit>::iterator it_s;
+    for(it_s = feeSplits.begin(); it_s != feeSplits.end(); ++it_s) {
+      (*it_s).clearId();
+      t.addSplit(*it_s);
+    }
+
+    for(it_s = interestSplits.begin(); it_s != interestSplits.end(); ++it_s) {
+      (*it_s).clearId();
+      t.addSplit(*it_s);
+    }
+  }
+
+  // adjust the value to the smallestAccountFraction found
+  // for the commodity of the transaction.
+  for(it_s = t.splits().begin(); it_s != t.splits().end(); ++it_s) {
+    MyMoneySplit s = (*it_s);
+    s.setValue((*it_s).value().convert(currency.smallestAccountFraction()));
+    t.modifySplit(s);
+  }
+
+  return rc;
+}
+
+void InvestTransactionEditor::updatePriceMode(const MyMoneySplit& split)
+{
+  QLabel* label = dynamic_cast<QLabel*>(haveWidget("price-label"));
+  if(label) {
+    kMyMoneyEdit* sharesEdit = dynamic_cast<kMyMoneyEdit*>(haveWidget("shares"));
+    kMyMoneyEdit* priceEdit = dynamic_cast<kMyMoneyEdit*>(haveWidget("price"));
+    MyMoneyMoney price;
+    if(!split.id().isEmpty())
+      price = split.price().reduce();
+    else
+      price = priceEdit->value().abs();
+
+    if(priceMode() == PricePerTransaction && label->text() != i18n("Price")) {
+      label->setText(i18n("Price"));
+      if(!sharesEdit->value().isZero())
+        priceEdit->setValue(sharesEdit->value().abs() * price);
+
+    } else if(priceMode() == PricePerShare && label->text() == i18n("Price")) {
+      label->setText(i18n("Price/Share"));
+      if(!sharesEdit->value().isZero())
+        priceEdit->setValue(price / sharesEdit->value().abs());
+
+    } else if(priceMode() == PricePerTransaction) {
+      priceEdit->setValue(sharesEdit->value().abs() * price);
+
+    } else
+      priceEdit->setValue(price);
+  }
+}
+
+void InvestTransactionEditor::setupFinalWidgets(void)
+{
+  addFinalWidget(haveWidget("memo"));
+}
+
+#include "investtransactioneditor.moc"
+