Added kmymoney

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

1 files changed, 2336 insertions, 0 deletions

diff --git a/kmymoney2/converter/mymoneyqifreader.cpp b/kmymoney2/converter/mymoneyqifreader.cpp
new file mode 100644
index 0000000..60b0604
--- /dev/null
+++ b/kmymoney2/converter/mymoneyqifreader.cpp
@@ -0,0 +1,2336 @@
+/***************************************************************************
+                          mymoneyqifreader.cpp
+                             -------------------
+    begin                : Mon Jan 27 2003
+    copyright            : (C) 2000-2003 by Michael Edwardes
+    email                : mte@users.sourceforge.net
+                           Javier Campos Morales <javi_c@users.sourceforge.net>
+                           Felix Rodriguez <frodriguez@users.sourceforge.net>
+                           John C <thetacoturtle@users.sourceforge.net>
+                           Thomas Baumgart <ipwizard@users.sourceforge.net>
+                           Kevin Tambascio <ktambascio@users.sourceforge.net>
+                           Ace Jones <acejones@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 <iostream>
+
+// ----------------------------------------------------------------------------
+// QT Headers
+
+#include <qfile.h>
+#include <qstringlist.h>
+#include <qtimer.h>
+#include <qtextedit.h>
+#include <qregexp.h>
+#include <qbuffer.h>
+
+// ----------------------------------------------------------------------------
+// KDE Headers
+
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kconfig.h>
+#include <kdebug.h>
+#include <kprogress.h>
+#include <kinputdialog.h>
+#include <kio/netaccess.h>
+
+// ----------------------------------------------------------------------------
+// Project Headers
+
+#include "mymoneyqifreader.h"
+#include "../mymoney/mymoneyfile.h"
+#include "../dialogs/kaccountselectdlg.h"
+#include "../kmymoney2.h"
+#include "kmymoneyglobalsettings.h"
+
+#include "mymoneystatementreader.h"
+#include <kmymoney/mymoneystatement.h>
+
+// define this to debug the code. Using external filters
+// while debugging did not work too good for me, so I added
+// this code.
+// #define DEBUG_IMPORT
+
+#ifdef DEBUG_IMPORT
+#warning "DEBUG_IMPORT defined --> external filter not available!!!!!!!"
+#endif
+
+class MyMoneyQifReader::Private {
+  public:
+    Private() :
+      accountType(MyMoneyAccount::Checkings),
+      mapCategories(true)
+    {}
+
+    QString accountTypeToQif(MyMoneyAccount::accountTypeE type) const;
+
+    /**
+     * finalize the current statement and add it to the statement list
+     */
+    void finishStatement(void);
+
+    bool isTransfer(QString& name, const QString& leftDelim, const QString& rightDelim);
+
+    /**
+     * Converts the QIF specific N-record of investment transactions into
+     * a category name
+     */
+    QString typeToAccountName(const QString& type) const;
+
+    /**
+     * Converts the QIF reconcile state to the KMyMoney reconcile state
+     */
+    MyMoneySplit::reconcileFlagE reconcileState(const QString& state) const;
+
+    /**
+      */
+    void fixMultiLineMemo(QString& memo) const;
+
+  public:
+    /**
+     * the statement that is currently collected/processed
+     */
+    MyMoneyStatement st;
+    /**
+     * the list of all statements to be sent to MyMoneyStatementReader
+     */
+    QValueList<MyMoneyStatement> statements;
+
+    /**
+     * a list of already used hashes in this file
+     */
+    QMap<QString, bool> m_hashMap;
+
+    QString st_AccountName;
+    QString st_AccountId;
+    MyMoneyAccount::accountTypeE accountType;
+    bool     firstTransaction;
+    bool     mapCategories;
+    MyMoneyQifReader::QifEntryTypeE  transactionType;
+};
+
+void MyMoneyQifReader::Private::fixMultiLineMemo(QString& memo) const
+{
+  memo.replace("\\n", "\n");
+}
+
+void MyMoneyQifReader::Private::finishStatement(void)
+{
+  // in case we have collected any data in the statement, we keep it
+  if((st.m_listTransactions.count() + st.m_listPrices.count() + st.m_listSecurities.count()) > 0) {
+    statements += st;
+    qDebug("Statement with %d transactions, %d prices and %d securities added to the statement list",
+           st.m_listTransactions.count(), st.m_listPrices.count(), st.m_listSecurities.count());
+  }
+  // start with a fresh statement
+  st = MyMoneyStatement();
+  st.m_skipCategoryMatching = !mapCategories;
+  st.m_eType = (transactionType == MyMoneyQifReader::EntryTransaction) ? MyMoneyStatement::etCheckings : MyMoneyStatement::etInvestment;
+}
+
+QString MyMoneyQifReader::Private::accountTypeToQif(MyMoneyAccount::accountTypeE type) const
+{
+  QString rc = "Bank";
+
+  switch(type) {
+    default:
+      break;
+    case MyMoneyAccount::Cash:
+      rc = "Cash";
+      break;
+    case MyMoneyAccount::CreditCard:
+      rc = "CCard";
+      break;
+    case MyMoneyAccount::Asset:
+      rc = "Oth A";
+      break;
+    case MyMoneyAccount::Liability:
+      rc = "Oth L";
+      break;
+    case MyMoneyAccount::Investment:
+      rc = "Port";
+      break;
+  }
+  return rc;
+}
+
+QString MyMoneyQifReader::Private::typeToAccountName(const QString& type) const
+{
+  if(type == "reinvdiv")
+    return i18n("Category name", "Reinvested dividend");
+
+  if(type == "reinvlg")
+    return i18n("Category name", "Reinvested dividend (long term)");
+
+  if(type == "reinvsh")
+    return i18n("Category name", "Reinvested dividend (short term)");
+
+  if (type == "div")
+    return i18n("Category name", "Dividend");
+
+  if(type == "intinc")
+    return i18n("Category name", "Interest");
+
+  if(type == "cgshort")
+    return i18n("Category name", "Capital Gain (short term)");
+
+  if( type == "cgmid")
+    return i18n("Category name", "Capital Gain (mid term)");
+
+  if(type == "cglong")
+    return i18n("Category name", "Capital Gain (long term)");
+
+  if(type == "rtrncap")
+    return i18n("Category name", "Returned capital");
+
+  if(type == "miscinc")
+    return i18n("Category name", "Miscellaneous income");
+
+  if(type == "miscexp")
+    return i18n("Category name", "Miscellaneous expense");
+
+  if(type == "sell" || type == "buy")
+    return i18n("Category name", "Investment fees");
+
+  return i18n("Unknown QIF type %1").arg(type);
+}
+
+bool MyMoneyQifReader::Private::isTransfer(QString& tmp, const QString& leftDelim, const QString& rightDelim)
+{
+  // it's a transfer, extract the account name
+  // I've seen entries like this
+  //
+  // S[Mehrwertsteuer]/_VATCode_N_I
+  //
+  // so extracting is a bit more complex and we use a regexp for it
+  QRegExp exp(QString("\\%1(.*)\\%2(.*)").arg(leftDelim, rightDelim));
+
+  bool rc;
+  if((rc = (exp.search(tmp) != -1)) == true) {
+    tmp = exp.cap(1)+exp.cap(2);
+    tmp = tmp.stripWhiteSpace();
+  }
+  return rc;
+}
+
+MyMoneySplit::reconcileFlagE MyMoneyQifReader::Private::reconcileState(const QString& state) const
+{
+  if(state == "X" || state == "R")        // Reconciled
+    return MyMoneySplit::Reconciled;
+
+  if(state == "*")                      // Cleared
+    return MyMoneySplit::Cleared;
+
+  return MyMoneySplit::NotReconciled;
+}
+
+
+MyMoneyQifReader::MyMoneyQifReader() :
+  d(new Private)
+{
+  m_skipAccount = false;
+  m_transactionsProcessed =
+  m_transactionsSkipped = 0;
+  m_progressCallback = 0;
+  m_file = 0;
+  m_entryType = EntryUnknown;
+  m_processingData = false;
+  m_userAbort = false;
+  m_warnedInvestment = false;
+  m_warnedSecurity = false;
+  m_warnedPrice = false;
+
+  connect(&m_filter, SIGNAL(wroteStdin(KProcess*)), this, SLOT(slotSendDataToFilter()));
+  connect(&m_filter, SIGNAL(receivedStdout(KProcess*, char*, int)), this, SLOT(slotReceivedDataFromFilter(KProcess*, char*, int)));
+  connect(&m_filter, SIGNAL(processExited(KProcess*)), this, SLOT(slotImportFinished()));
+  connect(&m_filter, SIGNAL(receivedStderr(KProcess*, char*, int)), this, SLOT(slotReceivedErrorFromFilter(KProcess*, char*, int)));
+}
+
+MyMoneyQifReader::~MyMoneyQifReader()
+{
+  if(m_file)
+    delete m_file;
+  delete d;
+}
+
+void MyMoneyQifReader::setCategoryMapping(bool map)
+{
+  d->mapCategories = map;
+}
+
+void MyMoneyQifReader::setURL(const KURL& url)
+{
+  m_url = url;
+}
+
+void MyMoneyQifReader::setProfile(const QString& profile)
+{
+  m_qifProfile.loadProfile("Profile-" + profile);
+}
+
+void MyMoneyQifReader::slotSendDataToFilter(void)
+{
+  Q_LONG len;
+
+  if(m_file->atEnd()) {
+    // m_filter.flushStdin();
+    m_filter.closeStdin();
+  } else {
+    len = m_file->readBlock(m_buffer, sizeof(m_buffer));
+    if(len == -1) {
+      qWarning("Failed to read block from QIF import file");
+      m_filter.closeStdin();
+      m_filter.kill();
+    } else {
+      m_filter.writeStdin(m_buffer, len);
+    }
+  }
+}
+
+void MyMoneyQifReader::slotReceivedErrorFromFilter(KProcess* /* proc */, char *buff, int len)
+{
+  QByteArray data;
+  data.duplicate(buff, len);
+  qWarning("%s",static_cast<const char*>(data));
+}
+
+void MyMoneyQifReader::slotReceivedDataFromFilter(KProcess* /* proc */, char *buff, int len)
+{
+  m_pos += len;
+  // signalProgress(m_pos, 0);
+
+  while(len) {
+    // process char
+    if(*buff == '\n' || *buff == '\r') {
+      // found EOL
+      if(!m_lineBuffer.isEmpty()) {
+        m_qifLines << QString::fromUtf8(m_lineBuffer.stripWhiteSpace());
+      }
+      m_lineBuffer = QCString();
+    } else {
+      // collect all others
+      m_lineBuffer += (*buff);
+    }
+    ++buff;
+    --len;
+  }
+}
+
+void MyMoneyQifReader::slotImportFinished(void)
+{
+  // check if the last EOL char was missing and add the trailing line
+  if(!m_lineBuffer.isEmpty()) {
+    m_qifLines << QString::fromUtf8(m_lineBuffer.stripWhiteSpace());
+  }
+  qDebug("Read %d bytes", m_pos);
+  QTimer::singleShot(0, this, SLOT(slotProcessData()));
+}
+
+void MyMoneyQifReader::slotProcessData(void)
+{
+  signalProgress(-1, -1);
+
+  // scan the file and try to determine numeric and date formats
+  m_qifProfile.autoDetect(m_qifLines);
+
+  // the detection is accurate for numeric values, but it could be
+  // that the dates were too ambiguous so that we have to let the user
+  // decide which one to pick.
+  QStringList dateFormats;
+  m_qifProfile.possibleDateFormats(dateFormats);
+  QStringList list;
+  if(dateFormats.count() > 1) {
+    list << dateFormats.first();
+    bool ok;
+    list = KInputDialog::getItemList(i18n("Date format selection"), i18n("Pick the date format that suits your input file"), dateFormats, list, false, &ok);
+    if(!ok) {
+      m_userAbort = true;
+    }
+  } else
+    list = dateFormats;
+
+  m_qifProfile.setInputDateFormat(list.first());
+
+  qDebug("Selected date format: '%s'", list.first().data());
+
+  signalProgress(0, m_qifLines.count(), i18n("Importing QIF ..."));
+  QStringList::iterator it;
+  for(it = m_qifLines.begin(); m_userAbort == false && it != m_qifLines.end(); ++it) {
+    ++m_linenumber;
+    // qDebug("Proc: '%s'", (*it).data());
+    if((*it).startsWith("!")) {
+      processQifSpecial(*it);
+      m_qifEntry.clear();
+    } else if(*it == "^") {
+      if(m_qifEntry.count() > 0) {
+        signalProgress(m_linenumber, 0);
+        processQifEntry();
+        m_qifEntry.clear();
+      }
+    } else {
+      m_qifEntry += *it;
+    }
+  }
+  d->finishStatement();
+
+  qDebug("%d lines processed", m_linenumber);
+  signalProgress(-1, -1);
+
+  emit importFinished();
+}
+
+bool MyMoneyQifReader::startImport(void)
+{
+  bool rc = false;
+  d->st = MyMoneyStatement();
+  d->st.m_skipCategoryMatching = !d->mapCategories;
+  m_dontAskAgain.clear();
+  m_accountTranslation.clear();
+  m_userAbort = false;
+  m_pos = 0;
+  m_linenumber = 0;
+  m_filename = QString::null;
+  m_data.clear();
+
+  if(!KIO::NetAccess::download(m_url, m_filename, NULL)) {
+    KMessageBox::detailedError(0,
+                               i18n("Error while loading file '%1'!").arg(m_url.prettyURL()),
+                               KIO::NetAccess::lastErrorString(),
+                               i18n("File access error"));
+    return false;
+  }
+
+  m_file = new QFile(m_filename);
+  if(m_file->open(IO_ReadOnly)) {
+
+#ifdef DEBUG_IMPORT
+    Q_LONG len;
+
+    while(!m_file->atEnd()) {
+      len = m_file->readBlock(m_buffer, sizeof(m_buffer));
+      if(len == -1) {
+        qWarning("Failed to read block from QIF import file");
+      } else {
+        slotReceivedDataFromFilter(0, m_buffer, len);
+      }
+    }
+    slotImportFinished();
+
+#else
+    // start filter process, use 'cat -' as the default filter
+    m_filter.clearArguments();
+    if(m_qifProfile.filterScriptImport().isEmpty()) {
+      m_filter << "cat";
+      m_filter << "-";
+    } else {
+      m_filter << QStringList::split(" ", m_qifProfile.filterScriptImport(), true);
+    }
+    m_entryType = EntryUnknown;
+
+    if(m_filter.start(KProcess::NotifyOnExit, KProcess::All)) {
+      m_filter.resume();
+      signalProgress(0, m_file->size(), i18n("Reading QIF ..."));
+      slotSendDataToFilter();
+      rc = true;
+    } else {
+      qDebug("starting filter failed :-(");
+    }
+#endif
+  }
+  return rc;
+}
+
+bool MyMoneyQifReader::finishImport(void)
+{
+  bool  rc = false;
+
+#ifdef DEBUG_IMPORT
+  delete m_file;
+  m_file = 0;
+
+  // remove the Don't ask again entries
+  KConfig* config = KGlobal::config();
+  config->setGroup(QString::fromLatin1("Notification Messages"));
+  QStringList::ConstIterator it;
+
+  for(it = m_dontAskAgain.begin(); it != m_dontAskAgain.end(); ++it) {
+    config->deleteEntry(*it);
+  }
+  config->sync();
+  m_dontAskAgain.clear();
+  m_accountTranslation.clear();
+
+  signalProgress(-1, -1);
+  rc = !m_userAbort;
+
+#else
+  if(!m_filter.isRunning()) {
+    delete m_file;
+    m_file = 0;
+
+    // remove the Don't ask again entries
+    KConfig* config = KGlobal::config();
+    config->setGroup(QString::fromLatin1("Notification Messages"));
+    QStringList::ConstIterator it;
+
+    for(it = m_dontAskAgain.begin(); it != m_dontAskAgain.end(); ++it) {
+      config->deleteEntry(*it);
+    }
+    config->sync();
+    m_dontAskAgain.clear();
+    m_accountTranslation.clear();
+
+    signalProgress(-1, -1);
+    rc = !m_userAbort && m_filter.normalExit();
+  } else {
+    qWarning("MyMoneyQifReader::finishImport() must not be called while the filter\n\tprocess is still running.");
+  }
+#endif
+
+  // if a temporary file was constructed by NetAccess::download,
+  // then it will be removed with the next call. Otherwise, it
+  // stays untouched on the local filesystem
+  KIO::NetAccess::removeTempFile(m_filename);
+
+#if 0
+  // Add the transaction entries
+  KProgressDialog dlg(0,"transactionaddprogress",i18n("Adding transactions"),i18n("Now adding the transactions to your ledger..."));
+  dlg.progressBar()->setTotalSteps(m_transactionCache.count());
+  dlg.progressBar()->setTextEnabled(true);
+  dlg.setAllowCancel(true);
+  dlg.show();
+  kapp->processEvents();
+  MyMoneyFile* file = MyMoneyFile::instance();
+  QValueList<MyMoneyTransaction>::iterator it = m_transactionCache.begin();
+  MyMoneyFileTransaction ft;
+  try
+  {
+    while( it != m_transactionCache.end() )
+    {
+      if ( dlg.wasCancelled() )
+      {
+        m_userAbort = true;
+        rc = false;
+        break;
+      }
+      file->addTransaction(*it);
+      dlg.progressBar()->advance(1);
+      ++it;
+    }
+    if(rc)
+      ft.commit();
+  } catch(MyMoneyException *e) {
+    KMessageBox::detailedSorry(0, i18n("Unable to add transactions"),
+    (e->what() + " " + i18n("thrown in") + " " + e->file()+ ":%1").arg(e->line()));
+    delete e;
+    rc = false;
+  }
+#endif
+  // Now to import the statements
+  QValueList<MyMoneyStatement>::const_iterator it_st;
+  for(it_st = d->statements.begin(); it_st != d->statements.end(); ++it_st)
+    kmymoney2->slotStatementImport(*it_st);
+  return rc;
+}
+
+void MyMoneyQifReader::processQifSpecial(const QString& _line)
+{
+  QString line = _line.mid(1);   // get rid of exclamation mark
+  // QString test = line.left(5).lower();
+  if(line.left(5).lower() == QString("type:")) {
+    line = line.mid(5);
+
+    // exportable accounts
+    if(line.lower() == "ccard" || KMyMoneyGlobalSettings::qifCreditCard().lower().contains(line.lower())) {
+      d->accountType = MyMoneyAccount::CreditCard;
+      d->firstTransaction = true;
+      d->transactionType = m_entryType = EntryTransaction;
+
+    } else if(line.lower() == "bank" || KMyMoneyGlobalSettings::qifBank().lower().contains(line.lower())) {
+      d->accountType = MyMoneyAccount::Checkings;
+      d->firstTransaction = true;
+      d->transactionType = m_entryType = EntryTransaction;
+
+    } else if(line.lower() == "cash" || KMyMoneyGlobalSettings::qifCash().lower().contains(line.lower())) {
+      d->accountType = MyMoneyAccount::Cash;
+      d->firstTransaction = true;
+      d->transactionType = m_entryType = EntryTransaction;
+
+    } else if(line.lower() == "oth a" || KMyMoneyGlobalSettings::qifAsset().lower().contains(line.lower())) {
+      d->accountType = MyMoneyAccount::Asset;
+      d->firstTransaction = true;
+      d->transactionType = m_entryType = EntryTransaction;
+
+    } else if(line.lower() == "oth l" || line.lower() == i18n("QIF tag for liability account", "Oth L").lower()) {
+      d->accountType = MyMoneyAccount::Liability;
+      d->firstTransaction = true;
+      d->transactionType = m_entryType = EntryTransaction;
+
+    } else if(line.lower() == "invst" || line.lower() == i18n("QIF tag for investment account", "Invst").lower()) {
+      d->transactionType = m_entryType = EntryInvestmentTransaction;
+
+    } else if(line.lower() == "invoice" || KMyMoneyGlobalSettings::qifInvoice().lower().contains(line.lower())) {
+      m_entryType = EntrySkip;
+
+    } else if(line.lower() == "tax") {
+      m_entryType = EntrySkip;
+
+    } else if(line.lower() == "bill") {
+      m_entryType = EntrySkip;
+
+    // exportable lists
+    } else if(line.lower() == "cat" || line.lower() == i18n("QIF tag for category", "Cat").lower()) {
+      m_entryType = EntryCategory;
+
+    } else if(line.lower() == "security" || line.lower() == i18n("QIF tag for security", "Security").lower()) {
+      m_entryType = EntrySecurity;
+
+    } else if(line.lower() == "prices" || line.lower() == i18n("QIF tag for prices", "Prices").lower()) {
+      m_entryType = EntryPrice;
+
+    } else if(line.lower() == "payee") {
+      m_entryType = EntryPayee;
+
+    } else if(line.lower() == "class" || line.lower() == i18n("QIF tag for a class", "Class").lower()) {
+      m_entryType = EntryClass;
+
+    } else if(line.lower() == "memorized") {
+      m_entryType = EntryMemorizedTransaction;
+
+    } else if(line.lower() == "budget") {
+      m_entryType = EntrySkip;
+
+    } else if(line.lower() == "invitem") {
+      m_entryType = EntrySkip;
+
+    } else if(line.lower() == "template") {
+      m_entryType = EntrySkip;
+
+    } else {
+      qWarning("Unknown export header '!Type:%s' in QIF file on line %d: Skipping section.", line.data(), m_linenumber);
+      m_entryType = EntrySkip;
+    }
+
+  // account headers
+  } else if(line.lower() == "account") {
+    m_entryType = EntryAccount;
+
+  } else if(line.lower() == "option:autoswitch") {
+    m_entryType = EntryAccount;
+
+  } else if(line.lower() == "clear:autoswitch") {
+    m_entryType = d->transactionType;
+  }
+}
+
+void MyMoneyQifReader::processQifEntry(void)
+{
+  // This method processes a 'QIF Entry' which is everything between two caret
+  // signs
+  //
+  try {
+    switch(m_entryType) {
+      case EntryCategory:
+        processCategoryEntry();
+        break;
+
+      case EntryUnknown:
+        kdDebug(2) << "Line " << m_linenumber << ": Warning: Found an entry without a type being specified. Checking assumed." << endl;
+        processTransactionEntry();
+        break;
+
+      case EntryTransaction:
+        processTransactionEntry();
+        break;
+
+      case EntryInvestmentTransaction:
+        processInvestmentTransactionEntry();
+        break;
+
+      case EntryAccount:
+        processAccountEntry();
+        break;
+
+      case EntrySecurity:
+        processSecurityEntry();
+        break;
+
+      case EntryPrice:
+        processPriceEntry();
+        break;
+
+      case EntryPayee:
+        processPayeeEntry();
+        break;
+
+      case EntryClass:
+        kdDebug(2) << "Line " << m_linenumber << ": Classes are not yet supported!" << endl;
+        break;
+
+      case EntryMemorizedTransaction:
+        kdDebug(2) << "Line " << m_linenumber << ": Memorized transactions are not yet implemented!" << endl;
+        break;
+
+      case EntrySkip:
+        break;
+
+      default:
+        kdDebug(2) << "Line " << m_linenumber<< ": EntryType " << m_entryType <<" not yet implemented!" << endl;
+        break;
+    }
+  } catch(MyMoneyException *e) {
+    if(e->what() != "USERABORT") {
+      kdDebug(2) << "Line " << m_linenumber << ": Unhandled error: " << e->what() << endl;
+    } else {
+      m_userAbort = true;
+    }
+    delete e;
+  }
+}
+
+const QString MyMoneyQifReader::extractLine(const QChar id, int cnt)
+{
+  QStringList::ConstIterator it;
+
+  m_extractedLine = -1;
+  for(it = m_qifEntry.begin(); it != m_qifEntry.end(); ++it) {
+    m_extractedLine++;
+    if((*it)[0] == id) {
+      if(cnt-- == 1) {
+        if((*it).mid(1).isEmpty())
+          return QString(" ");
+        return (*it).mid(1);
+      }
+    }
+  }
+  m_extractedLine = -1;
+  return QString();
+}
+
+void MyMoneyQifReader::extractSplits(QValueList<qSplit>& listqSplits) const
+{
+//     *** With apologies to QString MyMoneyQifReader::extractLine ***
+
+  QStringList::ConstIterator it;
+
+  for(it = m_qifEntry.begin(); it != m_qifEntry.end(); ++it) {
+    if((*it)[0] == "S") {
+      qSplit q;
+      q.m_strCategoryName = (*it++).mid(1);       //   'S'
+      if((*it)[0] == "E") {
+        q.m_strMemo =  (*it++).mid(1);    //           'E'
+        d->fixMultiLineMemo(q.m_strMemo);
+      }
+      if((*it)[0] == "$") {
+        q.m_amount =  (*it).mid(1);    //              '$'
+      }
+      listqSplits += q;
+    }
+  }
+}
+#if 0
+void MyMoneyQifReader::processMSAccountEntry(const MyMoneyAccount::accountTypeE accountType)
+{
+  if(extractLine('P').lower() == m_qifProfile.openingBalanceText().lower()) {
+    m_account = MyMoneyAccount();
+    m_account.setAccountType(accountType);
+    QString txt = extractLine('T');
+    MyMoneyMoney balance = m_qifProfile.value('T', txt);
+
+    QDate date = m_qifProfile.date(extractLine('D'));
+    m_account.setOpeningDate(date);
+
+    QString name = extractLine('L');
+    if(name.left(1) == m_qifProfile.accountDelimiter().left(1)) {
+      name = name.mid(1, name.length()-2);
+    }
+    d->st_AccountName = name;
+    m_account.setName(name);
+    selectOrCreateAccount(Select, m_account, balance);
+    d->st.m_accountId = m_account.id();
+    if ( ! balance.isZero() )
+    {
+      MyMoneyFile* file = MyMoneyFile::instance();
+      QString openingtxid = file->openingBalanceTransaction(m_account);
+      MyMoneyFileTransaction ft;
+      if ( ! openingtxid.isEmpty() )
+      {
+        MyMoneyTransaction openingtx = file->transaction(openingtxid);
+        MyMoneySplit split = openingtx.splitByAccount(m_account.id());
+
+        if ( split.shares() != balance )
+        {
+          const MyMoneySecurity& sec = file->security(m_account.currencyId());
+          if ( KMessageBox::questionYesNo(
+            qApp->mainWidget(),
+            i18n("The %1 account currently has an opening balance of %2. This QIF file reports an opening balance of %3. Would you like to overwrite the current balance with the one from the QIF file?").arg(m_account.name(), split.shares().formatMoney(m_account, sec),balance.formatMoney(m_account, sec)),
+            i18n("Overwrite opening balance"),
+            KStdGuiItem::yes(),
+            KStdGuiItem::no(),
+            "OverwriteOpeningBalance" )
+            == KMessageBox::Yes )
+          {
+            file->removeTransaction( openingtx );
+            m_account.setOpeningDate( date );
+            file->createOpeningBalanceTransaction( m_account, balance );
+          }
+        }
+
+      }
+      else
+      {
+        // Add an opening balance
+        m_account.setOpeningDate( date );
+        file->createOpeningBalanceTransaction( m_account, balance );
+      }
+      ft.commit();
+    }
+
+  } else {
+    // for some unknown reason, Quicken 2001 generates the following (somewhat
+    // misleading) sequence of lines:
+    //
+    //  1: !Account
+    //  2: NAT&T Universal
+    //  3: DAT&T Univers(...xxxx) [CLOSED]
+    //  4: TCCard
+    //  5: ^
+    //  6: !Type:CCard
+    //  7: !Account
+    //  8: NCFCU Visa
+    //  9: DRick's CFCU Visa card (...xxxx)
+    // 10: TCCard
+    // 11: ^
+    // 12: !Type:CCard
+    // 13: D1/ 4' 1
+    //
+    // Lines 1-5 are processed via processQifEntry() and processAccountEntry()
+    // Then Quicken issues line 6 but since the account does not carry any
+    // transaction does not write an end delimiter. Arrrgh! So we end up with
+    // a QIF entry comprising of lines 6-11 and end up in this routine. Actually,
+    // lines 7-11 are the leadin for the next account. So we check here if
+    // the !Type:xxx record also contains an !Account line and process the
+    // entry as required.
+    //
+    // (Ace) I think a better solution here is to handle exclamation point
+    // lines separately from entries.  In the above case:
+    // Line 1 would set the mode to "account entries".
+    // Lines 2-5 would be interpreted as an account entry.  This would set m_account.
+    // Line 6 would set the mode to "cc transaction entries".
+    // Line 7 would immediately set the mode to "account entries" again
+    // Lines 8-11 would be interpreted as an account entry.  This would set m_account.
+    // Line 12 would set the mode to "cc transaction entries"
+    // Lines 13+ would be interpreted as cc transaction entries, and life is good
+    int exclamationCnt = 1;
+    QString category;
+    do {
+      category = extractLine('!', exclamationCnt++);
+    } while(!category.isEmpty() && category != "Account");
+
+    // we have such a weird empty account
+    if(category == "Account") {
+      processAccountEntry();
+    } else
+    {
+      selectOrCreateAccount(Select, m_account);
+
+      d->st_AccountName = m_account.name();
+      d->st.m_strAccountName = m_account.name();
+      d->st.m_accountId = m_account.id();
+      d->st.m_strAccountNumber = m_account.id();
+      m_account.setNumber(m_account.id());
+      if ( m_entryType == EntryInvestmentTransaction )
+        processInvestmentTransactionEntry();
+      else
+        processTransactionEntry();
+    }
+  }
+}
+#endif
+
+void MyMoneyQifReader::processPayeeEntry(void)
+{
+  // TODO
+}
+
+void MyMoneyQifReader::processCategoryEntry(void)
+{
+  MyMoneyFile* file = MyMoneyFile::instance();
+  MyMoneyAccount account = MyMoneyAccount();
+  account.setName(extractLine('N'));
+  account.setDescription(extractLine('D'));
+
+  MyMoneyAccount parentAccount;
+  if(!extractLine('I').isEmpty()) {
+    account.setAccountType(MyMoneyAccount::Income);
+    parentAccount = file->income();
+  } else if(!extractLine('E').isEmpty()) {
+    account.setAccountType(MyMoneyAccount::Expense);
+    parentAccount = file->expense();
+  }
+
+  // check if we can find the account already in the file
+  MyMoneyAccount acc = kmymoney2->findAccount(account, MyMoneyAccount());
+
+  // if not, we just create it
+  if(acc.id().isEmpty()) {
+    MyMoneyAccount brokerage;
+    MyMoneyMoney balance;
+    kmymoney2->createAccount(account, parentAccount, brokerage, balance);
+  }
+}
+
+QString MyMoneyQifReader::transferAccount(QString name, bool useBrokerage)
+{
+  QString accountId;
+  QStringList tmpEntry = m_qifEntry;   // keep temp copies
+  MyMoneyAccount tmpAccount = m_account;
+
+  m_qifEntry.clear();               // and construct a temp entry to create/search the account
+  m_qifEntry << QString("N%1").arg(name);
+  m_qifEntry << QString("Tunknown");
+  m_qifEntry << QString("D%1").arg(i18n("Autogenerated by QIF importer"));
+  accountId = processAccountEntry(false);
+
+  // in case we found a reference to an investment account, we need
+  // to switch to the brokerage account instead.
+  MyMoneyAccount acc = MyMoneyFile::instance()->account(accountId);
+  if(useBrokerage && (acc.accountType() == MyMoneyAccount::Investment)) {
+    name = acc.brokerageName();
+    m_qifEntry.clear();               // and construct a temp entry to create/search the account
+    m_qifEntry << QString("N%1").arg(name);
+    m_qifEntry << QString("Tunknown");
+    m_qifEntry << QString("D%1").arg(i18n("Autogenerated by QIF importer"));
+    accountId = processAccountEntry(false);
+  }
+  m_qifEntry = tmpEntry;               // restore local copies
+  m_account = tmpAccount;
+
+  return accountId;
+}
+
+void MyMoneyQifReader::createOpeningBalance(MyMoneyAccount::_accountTypeE accType)
+{
+  MyMoneyFile* file = MyMoneyFile::instance();
+
+  // if we don't have a name for the current account we need to extract the name from the L-record
+  if(m_account.name().isEmpty()) {
+    QString name = extractLine('L');
+    if(name.isEmpty()) {
+      name = i18n("QIF imported, no account name supplied");
+    }
+    d->isTransfer(name, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1,1));
+    QStringList entry = m_qifEntry;   // keep a temp copy
+    m_qifEntry.clear();               // and construct a temp entry to create/search the account
+    m_qifEntry << QString("N%1").arg(name);
+    m_qifEntry << QString("T%1").arg(d->accountTypeToQif(accType));
+    m_qifEntry << QString("D%1").arg(i18n("Autogenerated by QIF importer"));
+    processAccountEntry();
+    m_qifEntry = entry;               // restore local copy
+  }
+
+  MyMoneyFileTransaction ft;
+  try {
+    bool needCreate = true;
+
+    MyMoneyAccount acc = m_account;
+    // in case we're dealing with an investment account, we better use
+    // the accompanying brokerage account for the opening balance
+    acc = file->accountByName(m_account.brokerageName());
+
+    // check if we already have an opening balance transaction
+    QString tid = file->openingBalanceTransaction(acc);
+    MyMoneyTransaction ot;
+    if(!tid.isEmpty()) {
+      ot = file->transaction(tid);
+      MyMoneySplit s0 = ot.splitByAccount(acc.id());
+          // if the value is the same, we can silently skip this transaction
+      if(s0.shares() == m_qifProfile.value('T', extractLine('T'))) {
+        needCreate = false;
+      }
+      if(needCreate) {
+            // in case we create it anyway, we issue a warning to the user to check it manually
+        KMessageBox::sorry(0, QString("<qt>%1</qt>").arg(i18n("KMyMoney has imported a second opening balance transaction into account <b>%1</b> which differs from the one found already on file. Please correct this manually once the import is done.").arg(acc.name())), i18n("Opening balance problem"));
+      }
+    }
+
+    if(needCreate) {
+      acc.setOpeningDate(m_qifProfile.date(extractLine('D')));
+      file->modifyAccount(acc);
+      MyMoneyTransaction t = file->createOpeningBalanceTransaction(acc, m_qifProfile.value('T', extractLine('T')));
+      if(!t.id().isEmpty()) {
+        t.setImported();
+        file->modifyTransaction(t);
+      }
+      ft.commit();
+    }
+
+    // make sure to use the updated version of the account
+    if(m_account.id() == acc.id())
+      m_account = acc;
+
+    // remember which account we created
+    d->st.m_accountId = m_account.id();
+  } catch(MyMoneyException* e) {
+    KMessageBox::detailedError(0,
+                               i18n("Error while creating opening balance transaction"),
+                                    QString("%1(%2):%3").arg(e->file()).arg(e->line()).arg(e->what()),
+                                            i18n("File access error"));
+    delete e;
+  }
+}
+
+void MyMoneyQifReader::processTransactionEntry(void)
+{
+  ++m_transactionsProcessed;
+  // in case the user selected to skip the account or the account
+  // was not found we skip this transaction
+/*
+  if(m_account.id().isEmpty()) {
+    m_transactionsSkipped++;
+    return;
+  }
+*/
+  MyMoneyFile* file = MyMoneyFile::instance();
+  MyMoneyStatement::Split s1;
+  MyMoneyStatement::Transaction tr;
+  QString tmp;
+  QString accountId;
+  int pos;
+  QString payee = extractLine('P');
+  unsigned long h;
+
+  h = MyMoneyTransaction::hash(m_qifEntry.join(";"));
+
+  QString hashBase;
+  hashBase.sprintf("%s-%07lx", m_qifProfile.date(extractLine('D')).toString(Qt::ISODate).data(), h);
+  int idx = 1;
+  QString hash;
+  for(;;) {
+    hash = QString("%1-%2").arg(hashBase).arg(idx);
+    QMap<QString, bool>::const_iterator it;
+    it = d->m_hashMap.find(hash);
+    if(it == d->m_hashMap.end()) {
+      d->m_hashMap[hash] = true;
+      break;
+    }
+    ++idx;
+  }
+  tr.m_strBankID = hash;
+
+  if(d->firstTransaction) {
+    // check if this is an opening balance transaction and process it out of the statement
+    if(!payee.isEmpty() && ((payee.lower() == "opening balance") || KMyMoneyGlobalSettings::qifOpeningBalance().lower().contains(payee.lower()))) {
+      createOpeningBalance();
+      d->firstTransaction = false;
+      return;
+    }
+  }
+
+  // Process general transaction data
+
+  if(d->st.m_accountId.isEmpty())
+    d->st.m_accountId = m_account.id();
+
+  s1.m_accountId = d->st.m_accountId;
+
+  d->st.m_eType = MyMoneyStatement::etCheckings;
+  tr.m_datePosted = (m_qifProfile.date(extractLine('D')));
+  if(!tr.m_datePosted.isValid())
+  {
+    int rc = KMessageBox::warningContinueCancel(0,
+         i18n("The date entry \"%1\" read from the file cannot be interpreted through the current "
+              "date profile setting of \"%2\".\n\nPressing \"Continue\" will "
+              "assign todays date to the transaction. Pressing \"Cancel\" will abort "
+              "the import operation. You can then restart the import and select a different "
+              "QIF profile or create a new one.")
+           .arg(extractLine('D')).arg(m_qifProfile.inputDateFormat()),
+         i18n("Invalid date format"));
+    switch(rc) {
+      case KMessageBox::Continue:
+        tr.m_datePosted = (QDate::currentDate());
+        break;
+
+      case KMessageBox::Cancel:
+        throw new MYMONEYEXCEPTION("USERABORT");
+        break;
+    }
+  }
+
+  tmp = extractLine('L');
+  pos = tmp.findRev("--");
+  if(tmp.left(1) == m_qifProfile.accountDelimiter().left(1)) {
+    // it's a transfer, so we wipe the memo
+//   tmp = "";         why??
+//    st.m_strAccountName = tmp;
+  } else if(pos != -1) {
+//    what's this?
+//    t.setValue("Dialog", tmp.mid(pos+2));
+    tmp = tmp.left(pos);
+  }
+//  t.setMemo(tmp);
+
+  // Assign the "#" field to the transaction's bank id
+  // This is the custom KMM extension to QIF for a unique ID
+  tmp = extractLine('#');
+  if(!tmp.isEmpty())
+  {
+     tr.m_strBankID = QString("ID %1").arg(tmp);
+  }
+
+#if 0
+  // Collect data for the account's split
+  s1.m_accountId = m_account.id();
+  tmp = extractLine('S');
+  pos = tmp.findRev("--");
+  if(pos != -1) {
+    tmp = tmp.left(pos);
+  }
+  if(tmp.left(1) == m_qifProfile.accountDelimiter().left(1))
+      // it's a transfer, extract the account name
+      tmp = tmp.mid(1, tmp.length()-2);
+  s1.m_strCategoryName = tmp;
+#endif
+  // TODO (Ace) Deal with currencies more gracefully.  QIF cannot deal with multiple
+  // currencies, so we should assume that transactions imported into a given
+  // account are in THAT ACCOUNT's currency.  If one of those involves a transfer
+  // to an account with a different currency, value and shares should be
+  // different.  (Shares is in the target account's currency, value is in the
+  // transaction's)
+
+
+  s1.m_amount = m_qifProfile.value('T', extractLine('T'));
+  tr.m_amount = m_qifProfile.value('T', extractLine('T'));
+  tr.m_shares = m_qifProfile.value('T', extractLine('T'));
+  tmp = extractLine('N');
+  if (!tmp.isEmpty())
+    tr.m_strNumber = tmp;
+
+  if(!payee.isEmpty()) {
+      tr.m_strPayee = payee;
+  }
+
+  tr.m_reconcile = d->reconcileState(extractLine('C'));
+  tr.m_strMemo = extractLine('M');
+  d->fixMultiLineMemo(tr.m_strMemo);
+  s1.m_strMemo = tr.m_strMemo;
+  // tr.m_listSplits.append(s1);
+
+  if(extractLine('$').isEmpty()) {
+    MyMoneyAccount account;
+    // use the same values for the second split, but clear the ID and reverse the value
+    MyMoneyStatement::Split s2 = s1;
+    s2.m_reconcile = tr.m_reconcile;
+    s2.m_amount = (-s1.m_amount);
+//    s2.clearId();
+
+    // standard transaction
+    tmp = extractLine('L');
+    if(d->isTransfer(tmp, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1))) {
+      accountId = transferAccount(tmp, false);
+
+    } else {
+/*      pos = tmp.findRev("--");
+      if(pos != -1) {
+        t.setValue("Dialog", tmp.mid(pos+2));
+        tmp = tmp.left(pos);
+      }*/
+
+      // it's an expense / income
+      tmp = tmp.stripWhiteSpace();
+      accountId = checkCategory(tmp, s1.m_amount, s2.m_amount);
+    }
+
+    if(!accountId.isEmpty()) {
+      try {
+        MyMoneyAccount account = file->account(accountId);
+        // FIXME: check that the type matches and ask if not
+
+        if ( account.accountType() == MyMoneyAccount::Investment )
+        {
+          kdDebug(0) << "Line " << m_linenumber << ": Cannot transfer to/from an investment account. Transaction ignored." << endl;
+          return;
+        }
+        if ( account.id() == m_account.id() )
+        {
+          kdDebug(0) << "Line " << m_linenumber << ": Cannot transfer to the same account. Transfer ignored." << endl;
+          accountId = QString();
+        }
+
+      } catch (MyMoneyException *e) {
+        kdDebug(0) << "Line " << m_linenumber << ": Account with id " << accountId.data() << " not found" << endl;
+        accountId = QString();
+        delete e;
+      }
+    }
+
+    if(!accountId.isEmpty()) {
+      s2.m_accountId = accountId;
+      s2.m_strCategoryName = tmp;
+      tr.m_listSplits.append(s2);
+    }
+
+  } else {
+    // split transaction
+    QValueList<qSplit> listqSplits;
+
+    extractSplits(listqSplits);   //      ****** ensure each field is ******
+                                  //      *   attached to correct split    *
+    int   count;
+
+    for(count = 1; !extractLine('$', count).isEmpty(); ++count)
+    {
+      MyMoneyStatement::Split s2 = s1;
+      s2.m_amount = (-m_qifProfile.value('$', listqSplits[count-1].m_amount));   // Amount of split
+      s2.m_strMemo = listqSplits[count-1].m_strMemo;                             // Memo in split
+      tmp = listqSplits[count-1].m_strCategoryName;                              // Category in split
+
+      if(d->isTransfer(tmp, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1)))
+      {
+        accountId = transferAccount(tmp, false);
+
+      } else {
+        pos = tmp.findRev("--");
+        if(pos != -1) {
+///          t.setValue("Dialog", tmp.mid(pos+2));
+          tmp = tmp.left(pos);
+        }
+        tmp = tmp.stripWhiteSpace();
+        accountId = checkCategory(tmp, s1.m_amount, s2.m_amount);
+      }
+
+      if(!accountId.isEmpty()) {
+        try {
+          MyMoneyAccount account = file->account(accountId);
+          // FIXME: check that the type matches and ask if not
+
+          if ( account.accountType() == MyMoneyAccount::Investment )
+          {
+            kdDebug(0) << "Line " << m_linenumber << ": Cannot convert a split transfer to/from an investment account. Split removed. Total amount adjusted from " << tr.m_amount.formatMoney("", 2) << " to " << (tr.m_amount + s2.m_amount).formatMoney("", 2) << "\n";
+            tr.m_amount += s2.m_amount;
+            continue;
+          }
+          if ( account.id() == m_account.id() )
+          {
+            kdDebug(0) << "Line " << m_linenumber << ": Cannot transfer to the same account. Transfer ignored." << endl;
+            accountId = QString();
+          }
+
+        } catch (MyMoneyException *e) {
+          kdDebug(0) << "Line " << m_linenumber << ": Account with id " << accountId.data() << " not found" << endl;
+          accountId = QString();
+          delete e;
+        }
+      }
+      if(!accountId.isEmpty())
+      {
+        s2.m_accountId = accountId;
+        s2.m_strCategoryName = tmp;
+        tr.m_listSplits += s2;
+        // in case the transaction does not have a memo and we
+        // process the first split just copy the memo over
+        if(tr.m_listSplits.count() == 1 && tr.m_strMemo.isEmpty())
+          tr.m_strMemo = s2.m_strMemo;
+      }
+      else
+      {
+        // TODO add an option to create a "Unassigned" category
+        // for now, we just drop the split which will show up as unbalanced
+        // transaction in the KMyMoney ledger view
+      }
+    }
+  }
+
+  // Add the transaction to the statement
+  d->st.m_listTransactions +=tr;
+}
+
+void MyMoneyQifReader::processInvestmentTransactionEntry(void)
+{
+//   kdDebug(2) << "Investment Transaction:" << m_qifEntry.count() << " lines" << endl;
+  /*
+  Items for Investment Accounts
+  Field   Indicator Explanation
+  D   Date
+  N   Action
+  Y   Security (NAME, not symbol)
+  I   Price
+  Q   Quantity (number of shares or split ratio)
+  T   Transaction amount
+  C   Cleared status
+  P   Text in the first line for transfers and reminders (Payee)
+  M   Memo
+  O   Commission
+  L   Account for the transfer
+  $   Amount transferred
+  ^   End of the entry
+
+  It will be presumed all transactions are to the associated cash account, if
+  one exists, unless otherwise noted by the 'L' field.
+
+  Expense/Income categories will be automatically generated, "_Dividend",
+  "_InterestIncome", etc.
+
+  */
+
+  MyMoneyFile* file = MyMoneyFile::instance();
+
+  MyMoneyStatement::Transaction tr;
+  d->st.m_eType = MyMoneyStatement::etInvestment;
+
+//  t.setCommodity(m_account.currencyId());
+  // 'D' field: Date
+  QDate date = m_qifProfile.date(extractLine('D'));
+  if(date.isValid())
+    tr.m_datePosted = date;
+  else
+  {
+    int rc = KMessageBox::warningContinueCancel(0,
+         i18n("The date entry \"%1\" read from the file cannot be interpreted through the current "
+              "date profile setting of \"%2\".\n\nPressing \"Continue\" will "
+              "assign todays date to the transaction. Pressing \"Cancel\" will abort "
+              "the import operation. You can then restart the import and select a different "
+              "QIF profile or create a new one.")
+           .arg(extractLine('D')).arg(m_qifProfile.inputDateFormat()),
+         i18n("Invalid date format"));
+    switch(rc) {
+      case KMessageBox::Continue:
+        tr.m_datePosted = QDate::currentDate();
+        break;
+
+      case KMessageBox::Cancel:
+        throw new MYMONEYEXCEPTION("USERABORT");
+        break;
+    }
+  }
+
+  // 'M' field: Memo
+  QString memo = extractLine('M');
+  d->fixMultiLineMemo(memo);
+  tr.m_strMemo = memo;
+  unsigned long h;
+
+  h = MyMoneyTransaction::hash(m_qifEntry.join(";"));
+
+  QString hashBase;
+  hashBase.sprintf("%s-%07lx", m_qifProfile.date(extractLine('D')).toString(Qt::ISODate).data(), h);
+  int idx = 1;
+  QString hash;
+  for(;;) {
+    hash = QString("%1-%2").arg(hashBase).arg(idx);
+    QMap<QString, bool>::const_iterator it;
+    it = d->m_hashMap.find(hash);
+    if(it == d->m_hashMap.end()) {
+      d->m_hashMap[hash] = true;
+      break;
+    }
+    ++idx;
+  }
+  tr.m_strBankID = hash;
+
+  // '#' field: BankID
+  QString tmp = extractLine('#');
+  if ( ! tmp.isEmpty() )
+    tr.m_strBankID = QString("ID %1").arg(tmp);
+
+  // Reconciliation flag
+  tr.m_reconcile = d->reconcileState(extractLine('C'));
+
+  // 'O' field: Fees
+  tr.m_fees = m_qifProfile.value('T', extractLine('O'));
+  // 'T' field: Amount
+  MyMoneyMoney amount = m_qifProfile.value('T', extractLine('T'));
+  tr.m_amount = amount;
+
+  MyMoneyStatement::Price price;
+
+  price.m_date = date;
+  price.m_strSecurity = extractLine('Y');
+  price.m_amount = m_qifProfile.value('T', extractLine('I'));
+
+#if 0 // we must check for that later, because certain activities don't need a security
+  // 'Y' field: Security name
+
+  QString securityname = extractLine('Y').lower();
+  if ( securityname.isEmpty() )
+  {
+    kdDebug(2) << "Line " << m_linenumber << ": Investment transaction without a security is not supported." << endl;
+    return;
+  }
+  tr.m_strSecurity = securityname;
+#endif
+
+#if 0
+
+  // For now, we let the statement reader take care of that.
+
+  // The big problem here is that the Y field is not the SYMBOL, it's the NAME.
+  // The name is not very unique, because people could have used slightly different
+  // abbreviations or ordered words differently, etc.
+  //
+  // If there is a perfect name match with a subordinate stock account, great.
+  // More likely, we have to rely on the QIF file containing !Type:Security
+  // records, which tell us the mapping from name to symbol.
+  //
+  // Therefore, generally it is not recommended to import a QIF file containing
+  // investment transactions but NOT containing security records.
+
+  QString securitysymbol = m_investmentMap[securityname];
+
+  // the correct account is the stock account which matches two criteria:
+  // (1) it is a sub-account of the selected investment account, and either
+  // (2a) the security name of the transaction matches the name of the security, OR
+  // (2b) the security name of the transaction maps to a symbol which matches the symbol of the security
+
+  // search through each subordinate account
+  bool found = false;
+  MyMoneyAccount thisaccount = m_account;
+  QStringList accounts = thisaccount.accountList();
+  QStringList::const_iterator it_account = accounts.begin();
+  while( !found && it_account != accounts.end() )
+  {
+    QString currencyid = file->account(*it_account).currencyId();
+    MyMoneySecurity security = file->security( currencyid );
+    QString symbol = security.tradingSymbol().lower();
+    QString name = security.name().lower();
+
+    if ( securityname == name || securitysymbol == symbol )
+    {
+      d->st_AccountId = *it_account;
+      s1.m_accountId = *it_account;
+      thisaccount = file->account(*it_account);
+      found = true;
+
+#if 0
+      // update the price, while we're here.  in the future, this should be
+      // an option
+      QString basecurrencyid = file->baseCurrency().id();
+      MyMoneyPrice price = file->price( currencyid, basecurrencyid, t_in.m_datePosted, true );
+      if ( !price.isValid() )
+      {
+        MyMoneyPrice newprice( currencyid, basecurrencyid, t_in.m_datePosted, t_in.m_moneyAmount / t_in.m_dShares, i18n("Statement Importer") );
+        file->addPrice(newprice);
+      }
+#endif
+    }
+
+    ++it_account;
+  }
+
+  if (!found)
+  {
+    kdDebug(2) << "Line " << m_linenumber << ": Security " << securityname << " not found in this account.  Transaction ignored." << endl;
+
+    // If the security is not known, notify the user
+    // TODO (Ace) A "SelectOrCreateAccount" interface for investments
+    KMessageBox::information(0, i18n("This investment account does not contain the \"%1\" security.  "
+                                      "Transactions involving this security will be ignored.").arg(securityname),
+                                i18n("Security not found"),
+                                QString("MissingSecurity%1").arg(securityname.stripWhiteSpace()));
+    return;
+  }
+#endif
+
+  // 'Y' field: Security
+  tr.m_strSecurity = extractLine('Y');
+
+  // 'Q' field: Quantity
+  MyMoneyMoney quantity = m_qifProfile.value('T', extractLine('Q'));
+
+  // 'N' field: Action
+  QString action = extractLine('N').lower();
+
+  // remove trailing X, which seems to have no purpose (?!)
+  bool xAction = false;
+  if ( action.endsWith("x") ) {
+    action = action.left( action.length() - 1 );
+    xAction = true;
+  }
+
+  // Whether to create a cash split for the other side of the value
+  QString accountname ;//= extractLine('L');
+  if ( action == "reinvdiv" || action == "reinvlg" || action == "reinvsh" )
+  {
+    d->st.m_listPrices += price;
+    tr.m_shares = quantity;
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaReinvestDividend);
+    tr.m_price = m_qifProfile.value('I', extractLine('I'));
+
+    tr.m_strInterestCategory = extractLine('L');
+    if(tr.m_strInterestCategory.isEmpty()) {
+      tr.m_strInterestCategory = d->typeToAccountName(action);
+    }
+  }
+  else if ( action == "div" || action == "cgshort" || action == "cgmid" || action == "cglong" || action == "rtrncap")
+  {
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaCashDividend);
+
+    QString tmp = extractLine('L');
+    // if the action ends in an X, the L-Record contains the asset account
+    // to which the dividend should be transferred. In the other cases, it
+    // may contain a category that identifies the income category for the
+    // dividend payment
+    if((xAction == true)
+    && (d->isTransfer(tmp, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1)) == true)) {
+      tr.m_strBrokerageAccount = tmp;
+      transferAccount(tmp);           // make sure the account exists
+    } else {
+      tr.m_strInterestCategory = tmp;
+    }
+
+    // make sure, we have valid category. Either taken from the L-Record above,
+    // or derived from the action code
+    if(tr.m_strInterestCategory.isEmpty()) {
+      tr.m_strInterestCategory = d->typeToAccountName(action);
+    }
+
+    // For historic reasons (coming from the OFX importer) the statement
+    // reader expects the dividend with a reverse sign. So we just do that.
+    tr.m_amount = -(amount - tr.m_fees);
+
+    // We need an extra split which will be the zero-amount investment split
+    // that serves to mark this transaction as a cash dividend and note which
+    // stock account it belongs to.
+    MyMoneyStatement::Split s2;
+    s2.m_amount = MyMoneyMoney();
+    s2.m_strCategoryName = extractLine('Y');
+    tr.m_listSplits.append(s2);
+  }
+  else if ( action == "intinc" || action == "miscinc" || action == "miscexp")
+  {
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaInterest);
+    if(action == "miscexp")
+      tr.m_eAction = (MyMoneyStatement::Transaction::eaFees);
+
+    QString tmp = extractLine('L');
+    // if the action ends in an X, the L-Record contains the asset account
+    // to which the dividend should be transferred. In the other cases, it
+    // may contain a category that identifies the income category for the
+    // payment
+    if((xAction == true)
+        && (d->isTransfer(tmp, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1)) == true)) {
+      tr.m_strBrokerageAccount = tmp;
+      transferAccount(tmp);           // make sure the account exists
+    } else {
+      tr.m_strInterestCategory = tmp;
+    }
+
+    // make sure, we have a valid category. Either taken from the L-Record above,
+    // or derived from the action code
+    if(tr.m_strInterestCategory.isEmpty()) {
+      tr.m_strInterestCategory = d->typeToAccountName(action);
+    }
+
+
+    // For historic reasons (coming from the OFX importer) the statement
+    // reader expects the dividend with a reverse sign. So we just do that.
+    if(action != "miscexp")
+      tr.m_amount = -(amount - tr.m_fees);
+
+    if(tr.m_strMemo.isEmpty())
+      tr.m_strMemo = (QString("%1 %2").arg(extractLine('Y')).arg(d->typeToAccountName(action))).stripWhiteSpace();
+  }
+  else if (action == "xin" || action == "xout")
+  {
+    QString payee = extractLine('P');
+    if(!payee.isEmpty() && ((payee.lower() == "opening balance") || KMyMoneyGlobalSettings::qifOpeningBalance().lower().contains(payee.lower()))) {
+      createOpeningBalance(MyMoneyAccount::Investment);
+      return;
+    }
+
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaNone);
+    MyMoneyStatement::Split s2;
+    QString tmp = extractLine('L');
+    if(d->isTransfer(tmp, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1))) {
+      s2.m_accountId = transferAccount(tmp);
+      s2.m_strCategoryName = tmp;
+    } else {
+      s2.m_strCategoryName = extractLine('L');
+      if(tr.m_strInterestCategory.isEmpty()) {
+        s2.m_strCategoryName = d->typeToAccountName(action);
+      }
+    }
+
+    if(action == "xout")
+      tr.m_amount = -tr.m_amount;
+
+    s2.m_amount = -tr.m_amount;
+    tr.m_listSplits.append(s2);
+  }
+  else if (action == "buy")
+  {
+    QString tmp = extractLine('L');
+    if(d->isTransfer(tmp, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1)) == true) {
+      tr.m_strBrokerageAccount = tmp;
+      transferAccount(tmp);           // make sure the account exists
+    }
+
+    d->st.m_listPrices += price;
+    tr.m_shares = quantity;
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaBuy);
+  }
+  else if (action == "sell")
+  {
+    QString tmp = extractLine('L');
+    if(d->isTransfer(tmp, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1)) == true) {
+      tr.m_strBrokerageAccount = tmp;
+      transferAccount(tmp);           // make sure the account exists
+    }
+
+    d->st.m_listPrices += price;
+    tr.m_shares = -quantity;
+    tr.m_amount = -amount;
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaSell);
+  }
+  else if ( action == "shrsin" )
+  {
+    tr.m_shares = quantity;
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaShrsin);
+  }
+  else if ( action == "shrsout" )
+  {
+    tr.m_shares = -quantity;
+    tr.m_eAction = (MyMoneyStatement::Transaction::eaShrsout);
+  }
+  else if ( action == "stksplit" )
+  {
+    MyMoneyMoney splitfactor = (quantity / MyMoneyMoney(10,1)).reduce();
+
+    // Stock splits not supported
+//     kdDebug(2) << "Line " << m_linenumber << ": Stock split not supported (date=" << date << " security=" << securityname << " factor=" << splitfactor.toString() << ")" << endl;
+
+//    s1.setShares(splitfactor);
+//    s1.setValue(0);
+//   s1.setAction(MyMoneySplit::ActionSplitShares);
+
+//     return;
+  }
+  else
+  {
+    // Unsupported action type
+    kdDebug(0) << "Line " << m_linenumber << ": Unsupported transaction action (" << action << ")" << endl;
+    return;
+  }
+  d->st.m_strAccountName = accountname;
+  d->st.m_listTransactions +=tr;
+
+  /*************************************************************************
+   *
+   * These transactions are natively supported by KMyMoney
+   *
+   *************************************************************************/
+  /*
+  D1/ 3' 5
+  NShrsIn
+  YGENERAL MOTORS CORP 52BR1
+  I20
+  Q200
+  U4,000.00
+  T4,000.00
+  M200 shares added to account @ $20/share
+  ^
+  */
+  /*
+  ^
+  D1/14' 5
+  NShrsOut
+  YTEMPLETON GROWTH 97GJ0
+  Q50
+90  ^
+  */
+  /*
+  D1/28' 5
+  NBuy
+  YGENERAL MOTORS CORP 52BR1
+  I24.35
+  Q100
+  U2,435.00
+  T2,435.00
+  ^
+  */
+  /*
+  D1/ 5' 5
+  NSell
+  YUnited Vanguard
+  I8.41
+  Q50
+  U420.50
+  T420.50
+  ^
+  */
+  /*
+  D1/ 7' 5
+  NReinvDiv
+  YFRANKLIN INCOME 97GM2
+  I38
+  Q1
+  U38.00
+  T38.00
+  ^
+  */
+  /*************************************************************************
+   *
+   * These transactions are all different kinds of income.  (Anything that
+   * follows the DNYUT pattern).  They are all handled the same, the only
+   * difference is which income account the income is placed into.  By
+   * default, it's placed into _xxx where xxx is the right side of the
+   * N field.  e.g. NDiv transaction goes into the _Div account
+   *
+   *************************************************************************/
+  /*
+  D1/10' 5
+  NDiv
+  YTEMPLETON GROWTH 97GJ0
+  U10.00
+  T10.00
+  ^
+  */
+  /*
+  D1/10' 5
+  NIntInc
+  YTEMPLETON GROWTH 97GJ0
+  U20.00
+  T20.00
+  ^
+  */
+  /*
+  D1/10' 5
+  NCGShort
+  YTEMPLETON GROWTH 97GJ0
+  U111.00
+  T111.00
+  ^
+  */
+  /*
+  D1/10' 5
+  NCGLong
+  YTEMPLETON GROWTH 97GJ0
+  U333.00
+  T333.00
+  ^
+  */
+  /*
+  D1/10' 5
+  NCGMid
+  YTEMPLETON GROWTH 97GJ0
+  U222.00
+  T222.00
+  ^
+  */
+  /*
+  D2/ 2' 5
+  NRtrnCap
+  YFRANKLIN INCOME 97GM2
+  U1,234.00
+  T1,234.00
+  ^
+  */
+  /*************************************************************************
+   *
+   * These transactions deal with miscellaneous activity that KMyMoney
+   * does not support, but may support in the future.
+   *
+   *************************************************************************/
+  /*   Note the Q field is the split ratio per 10 shares, so Q12.5 is a
+        12.5:10 split, otherwise known as 5:4.
+  D1/14' 5
+  NStkSplit
+  YIBM
+  Q12.5
+  ^
+  */
+  /*************************************************************************
+   *
+   * These transactions deal with short positions and options, which are
+   * not supported at all by KMyMoney.  They will be ignored for now.
+   * There may be a way to hack around this, by creating a new security
+   * "IBM_Short".
+   *
+   *************************************************************************/
+  /*
+  D1/21' 5
+  NShtSell
+  YIBM
+  I92.38
+  Q100
+  U9,238.00
+  T9,238.00
+  ^
+  */
+  /*
+  D1/28' 5
+  NCvrShrt
+  YIBM
+  I92.89
+  Q100
+  U9,339.00
+  T9,339.00
+  O50.00
+  ^
+  */
+  /*
+  D6/ 1' 5
+  NVest
+  YIBM Option
+  Q20
+  ^
+  */
+  /*
+  D6/ 8' 5
+  NExercise
+  YIBM Option
+  I60.952381
+  Q20
+  MFrom IBM Option Grant 6/1/2004
+  ^
+  */
+  /*
+  D6/ 1'14
+  NExpire
+  YIBM Option
+  Q5
+  ^
+  */
+  /*************************************************************************
+   *
+   * These transactions do not have an associated investment ("Y" field)
+   * so presumably they are only valid for the cash account.  Once I
+   * understand how these are really implemented, they can probably be
+   * handled without much trouble.
+   *
+   *************************************************************************/
+  /*
+  D1/14' 5
+  NCash
+  U-100.00
+  T-100.00
+  LBank Chrg
+  ^
+  */
+  /*
+  D1/15' 5
+  NXOut
+  U500.00
+  T500.00
+  L[CU Savings]
+  $500.00
+  ^
+  */
+  /*
+  D1/28' 5
+  NXIn
+  U1,000.00
+  T1,000.00
+  L[CU Checking]
+  $1,000.00
+  ^
+  */
+  /*
+  D1/25' 5
+  NMargInt
+  U25.00
+  T25.00
+  ^
+  */
+}
+
+const QString MyMoneyQifReader::findOrCreateIncomeAccount(const QString& searchname)
+{
+  QString result;
+
+  MyMoneyFile *file = MyMoneyFile::instance();
+
+  // First, try to find this account as an income account
+  MyMoneyAccount acc = file->income();
+  QStringList list = acc.accountList();
+  QStringList::ConstIterator it_accid = list.begin();
+  while ( it_accid != list.end() )
+  {
+    acc = file->account(*it_accid);
+    if ( acc.name() == searchname )
+    {
+      result = *it_accid;
+      break;
+    }
+    ++it_accid;
+  }
+
+  // If we did not find the account, now we must create one.
+  if ( result.isEmpty() )
+  {
+    MyMoneyAccount acc;
+    acc.setName( searchname );
+    acc.setAccountType( MyMoneyAccount::Income );
+    MyMoneyAccount income = file->income();
+    MyMoneyFileTransaction ft;
+    file->addAccount( acc, income );
+    ft.commit();
+    result = acc.id();
+  }
+
+  return result;
+}
+
+// TODO (Ace) Combine this and the previous function
+
+const QString MyMoneyQifReader::findOrCreateExpenseAccount(const QString& searchname)
+{
+  QString result;
+
+  MyMoneyFile *file = MyMoneyFile::instance();
+
+  // First, try to find this account as an income account
+  MyMoneyAccount acc = file->expense();
+  QStringList list = acc.accountList();
+  QStringList::ConstIterator it_accid = list.begin();
+  while ( it_accid != list.end() )
+  {
+    acc = file->account(*it_accid);
+    if ( acc.name() == searchname )
+    {
+      result = *it_accid;
+      break;
+    }
+    ++it_accid;
+  }
+
+  // If we did not find the account, now we must create one.
+  if ( result.isEmpty() )
+  {
+    MyMoneyAccount acc;
+    acc.setName( searchname );
+    acc.setAccountType( MyMoneyAccount::Expense );
+    MyMoneyFileTransaction ft;
+    MyMoneyAccount expense = file->expense();
+    file->addAccount( acc, expense );
+    ft.commit();
+    result = acc.id();
+  }
+
+  return result;
+}
+
+QString MyMoneyQifReader::checkCategory(const QString& name, const MyMoneyMoney value, const MyMoneyMoney value2)
+{
+  QString accountId;
+  MyMoneyFile *file = MyMoneyFile::instance();
+  MyMoneyAccount account;
+  bool found = true;
+
+  if(!name.isEmpty()) {
+    // The category might be constructed with an arbitraty depth (number of
+    // colon delimited fields). We try to find a parent account within this
+    // hierarchy by searching the following sequence:
+    //
+    //    aaaa:bbbb:cccc:ddddd
+    //
+    // 1. search aaaa:bbbb:cccc:dddd, create nothing
+    // 2. search aaaa:bbbb:cccc     , create dddd
+    // 3. search aaaa:bbbb          , create cccc:dddd
+    // 4. search aaaa               , create bbbb:cccc:dddd
+    // 5. don't search              , create aaaa:bbbb:cccc:dddd
+
+    account.setName(name);
+    QString accName;      // part to be created (right side in above list)
+    QString parent(name); // a possible parent part (left side in above list)
+    do {
+      accountId = file->categoryToAccount(parent);
+      if(accountId.isEmpty()) {
+        found = false;
+        // prepare next step
+        if(!accName.isEmpty())
+          accName.prepend(':');
+        accName.prepend(parent.section(':', -1));
+        account.setName(accName);
+        parent = parent.section(':', 0, -2);
+      } else if(!accName.isEmpty()) {
+        account.setParentAccountId(accountId);
+      }
+    }
+    while(!parent.isEmpty() && accountId.isEmpty());
+
+    // if we did not find the category, we create it
+    if(!found) {
+      MyMoneyAccount parent;
+      if(account.parentAccountId().isEmpty()) {
+        if(!value.isNegative() && value2.isNegative())
+          parent = file->income();
+        else
+          parent = file->expense();
+      } else {
+        parent = file->account(account.parentAccountId());
+      }
+      account.setAccountType((!value.isNegative() && value2.isNegative()) ? MyMoneyAccount::Income : MyMoneyAccount::Expense);
+      MyMoneyAccount brokerage;
+      // clear out the parent id, because createAccount() does not like that
+      account.setParentAccountId(QString());
+      kmymoney2->createAccount(account, parent, brokerage, MyMoneyMoney());
+      accountId = account.id();
+    }
+  }
+
+  return accountId;
+}
+
+QString MyMoneyQifReader::processAccountEntry(bool resetAccountId)
+{
+  MyMoneyFile* file = MyMoneyFile::instance();
+
+  MyMoneyAccount account;
+  QString tmp;
+
+  account.setName(extractLine('N'));
+  // qDebug("Process account '%s'", account.name().data());
+
+  account.setDescription(extractLine('D'));
+
+  tmp = extractLine('$');
+  if(tmp.length() > 0)
+    account.setValue("lastStatementBalance", tmp);
+
+  tmp = extractLine('/');
+  if(tmp.length() > 0)
+    account.setValue("lastStatementDate", m_qifProfile.date(tmp).toString("yyyy-MM-dd"));
+
+  QifEntryTypeE transactionType = EntryTransaction;
+  QString type = extractLine('T').lower().remove(QRegExp("\\s+"));
+  if(type == m_qifProfile.profileType().lower().remove(QRegExp("\\s+"))) {
+    account.setAccountType(MyMoneyAccount::Checkings);
+  } else if(type == "ccard" || type == "creditcard") {
+    account.setAccountType(MyMoneyAccount::CreditCard);
+  } else if(type == "cash") {
+    account.setAccountType(MyMoneyAccount::Cash);
+  } else if(type == "otha") {
+    account.setAccountType(MyMoneyAccount::Asset);
+  } else if(type == "othl") {
+    account.setAccountType(MyMoneyAccount::Liability);
+  } else if(type == "invst" || type == "port") {
+    account.setAccountType(MyMoneyAccount::Investment);
+    transactionType = EntryInvestmentTransaction;
+  } else if(type == "mutual") { // stock account w/o umbrella investment account
+    account.setAccountType(MyMoneyAccount::Stock);
+    transactionType = EntryInvestmentTransaction;
+  } else if(type == "unknown") {
+    // don't do anything with the type, leave it unknown
+  } else {
+    account.setAccountType(MyMoneyAccount::Checkings);
+    kdDebug(2) << "Line " << m_linenumber << ": Unknown account type '" << type << "', checkings assumed" << endl;
+  }
+
+  // check if we can find the account already in the file
+  MyMoneyAccount acc = kmymoney2->findAccount(account, MyMoneyAccount());
+  if(acc.id().isEmpty()) {
+    // in case the account is not found by name and the type is
+    // unknown, we have to assume something and create a checking account.
+    // this might be wrong, but we have no choice at this point.
+    if(account.accountType() == MyMoneyAccount::UnknownAccountType)
+      account.setAccountType(MyMoneyAccount::Checkings);
+
+    MyMoneyAccount parentAccount;
+    MyMoneyAccount brokerage;
+    MyMoneyMoney balance;
+    // in case it's a stock account, we need to setup a fix investment account
+    if(account.isInvest()) {
+      acc.setName(i18n("%1 (Investment)").arg(account.name()));    // use the same name for the investment account
+      acc.setDescription(i18n("Autogenerated by QIF importer from type Mutual account entry"));
+      acc.setAccountType(MyMoneyAccount::Investment);
+      parentAccount = file->asset();
+      kmymoney2->createAccount(acc, parentAccount, brokerage, MyMoneyMoney());
+      parentAccount = acc;
+      qDebug("We still need to create the stock account in MyMoneyQifReader::processAccountEntry()");
+    } else {
+      // setup parent according the type of the account
+      switch(account.accountGroup()) {
+        case MyMoneyAccount::Asset:
+        default:
+          parentAccount = file->asset();
+          break;
+        case MyMoneyAccount::Liability:
+          parentAccount = file->liability();
+          break;
+        case MyMoneyAccount::Equity:
+          parentAccount = file->equity();
+          break;
+      }
+    }
+
+    // investment accounts will receive a brokerage account, as KMyMoney
+    // currently does not allow to store funds in the investment account directly
+    if(account.accountType() == MyMoneyAccount::Investment) {
+      brokerage.setName(account.brokerageName());
+      brokerage.setAccountType(MyMoneyAccount::Checkings);
+      brokerage.setCurrencyId(MyMoneyFile::instance()->baseCurrency().id());
+    }
+    kmymoney2->createAccount(account, parentAccount, brokerage, balance);
+    acc = account;
+    // qDebug("Account created");
+  } else {
+    // qDebug("Existing account found");
+  }
+
+  if(resetAccountId) {
+    // possibly start a new statement
+    d->finishStatement();
+    m_account = acc;
+    d->st.m_accountId = m_account.id();
+    d->transactionType = transactionType;
+  }
+  return acc.id();
+}
+
+void MyMoneyQifReader::selectOrCreateAccount(const SelectCreateMode mode, MyMoneyAccount& account, const MyMoneyMoney& balance)
+{
+  MyMoneyFile* file = MyMoneyFile::instance();
+
+  QString accountId;
+  QString msg;
+  QString typeStr;
+  QString leadIn;
+  KMyMoneyUtils::categoryTypeE type;
+
+  QMap<QString, QString>::ConstIterator it;
+
+  type = KMyMoneyUtils::none;
+  switch(account.accountGroup()) {
+    default:
+      type = KMyMoneyUtils::asset;
+      type = (KMyMoneyUtils::categoryTypeE) (type | KMyMoneyUtils::liability);
+      typeStr = i18n("account");
+      leadIn = i18n("al");
+      break;
+
+    case MyMoneyAccount::Income:
+    case MyMoneyAccount::Expense:
+      type = KMyMoneyUtils::income;
+      type = (KMyMoneyUtils::categoryTypeE) (type | KMyMoneyUtils::expense);
+      typeStr = i18n("category");
+      leadIn = i18n("ei");
+      msg = i18n("Category selection");
+      break;
+  }
+
+  KAccountSelectDlg accountSelect(type, "QifImport", kmymoney2);
+  if(!msg.isEmpty())
+    accountSelect.setCaption(msg);
+
+  it = m_accountTranslation.find((leadIn + MyMoneyFile::AccountSeperator + account.name()).lower());
+  if(it != m_accountTranslation.end()) {
+    try {
+      account = file->account(*it);
+      return;
+
+    } catch (MyMoneyException *e) {
+      QString message(i18n("Account \"%1\" disappeared: ").arg(account.name()));
+      message += e->what();
+      KMessageBox::error(0, message);
+      delete e;
+    }
+  }
+
+  if(!account.name().isEmpty()) {
+    if(type & (KMyMoneyUtils::income | KMyMoneyUtils::expense)) {
+      accountId = file->categoryToAccount(account.name());
+    } else {
+      accountId = file->nameToAccount(account.name());
+    }
+
+    if(mode == Create) {
+      if(!accountId.isEmpty()) {
+        account = file->account(accountId);
+        return;
+
+      } else {
+        switch(KMessageBox::questionYesNo(0,
+                  i18n("The %1 '%2' does not exist. Do you "
+                       "want to create it?").arg(typeStr).arg(account.name()))) {
+          case KMessageBox::Yes:
+            break;
+          case KMessageBox::No:
+            return;
+        }
+      }
+    } else {
+      accountSelect.setHeader(i18n("Select %1").arg(typeStr));
+      if(!accountId.isEmpty()) {
+        msg = i18n("The %1 <b>%2</b> currently exists. Do you want "
+                   "to import transactions to this account?")
+                    .arg(typeStr).arg(account.name());
+
+      } else {
+        msg = i18n("The %1 <b>%2</b> currently does not exist. You can "
+                   "create a new %3 by pressing the <b>Create</b> button "
+                   "or select another %4 manually from the selection box.")
+                  .arg(typeStr).arg(account.name()).arg(typeStr).arg(typeStr);
+      }
+    }
+  } else {
+    accountSelect.setHeader(i18n("Import transactions to %1").arg(typeStr));
+    msg = i18n("No %1 information has been found in the selected QIF file. "
+               "Please select an account using the selection box in the dialog or "
+               "create a new %2 by pressing the <b>Create</b> button.")
+               .arg(typeStr).arg(typeStr);
+  }
+
+  accountSelect.setDescription(msg);
+  accountSelect.setAccount(account, accountId);
+  accountSelect.setMode(mode == Create);
+  accountSelect.showAbortButton(true);
+
+  // display current entry in widget, the offending line (if any) will be shown in red
+  QStringList::Iterator it_e;
+  int i = 0;
+  for(it_e = m_qifEntry.begin(); it_e != m_qifEntry.end(); ++it_e) {
+    if(m_extractedLine == i)
+      accountSelect.m_qifEntry->setColor(QColor("red"));
+    accountSelect.m_qifEntry->append(*it_e);
+    accountSelect.m_qifEntry->setColor(QColor("black"));
+    ++i;
+  }
+
+  for(;;) {
+    if(accountSelect.exec() == QDialog::Accepted) {
+      if(!accountSelect.selectedAccount().isEmpty()) {
+        accountId = accountSelect.selectedAccount();
+
+        m_accountTranslation[(leadIn + MyMoneyFile::AccountSeperator + account.name()).lower()] = accountId;
+
+        // MMAccount::openingBalance() is where the accountSelect dialog has
+        // stashed the opening balance that the user chose.
+        MyMoneyAccount importedAccountData(account);
+        // MyMoneyMoney balance = importedAccountData.openingBalance();
+        account = file->account(accountId);
+        if ( ! balance.isZero() )
+        {
+          QString openingtxid = file->openingBalanceTransaction(account);
+          MyMoneyFileTransaction ft;
+          if ( ! openingtxid.isEmpty() )
+          {
+            MyMoneyTransaction openingtx = file->transaction(openingtxid);
+            MyMoneySplit split = openingtx.splitByAccount(account.id());
+
+            if ( split.shares() != balance )
+            {
+              const MyMoneySecurity&  sec = file->security(account.currencyId());
+              if ( KMessageBox::questionYesNo(
+                qApp->mainWidget(),
+                i18n("The %1 account currently has an opening balance of %2. This QIF file reports an opening balance of %3. Would you like to overwrite the current balance with the one from the QIF file?").arg(account.name(), split.shares().formatMoney(account, sec), balance.formatMoney(account, sec)),
+                i18n("Overwrite opening balance"),
+                KStdGuiItem::yes(),
+                KStdGuiItem::no(),
+                "OverwriteOpeningBalance" )
+                == KMessageBox::Yes )
+              {
+                file->removeTransaction( openingtx );
+                file->createOpeningBalanceTransaction( account, balance );
+              }
+            }
+          }
+          else
+          {
+            // Add an opening balance
+            file->createOpeningBalanceTransaction( account, balance );
+          }
+          ft.commit();
+        }
+        break;
+      }
+
+    } else if(accountSelect.aborted())
+      throw new MYMONEYEXCEPTION("USERABORT");
+
+    if(typeStr == i18n("account")) {
+      KMessageBox::error(0, i18n("You must select or create an account."));
+    } else {
+      KMessageBox::error(0, i18n("You must select or create a category."));
+    }
+  }
+}
+
+void MyMoneyQifReader::setProgressCallback(void(*callback)(int, int, const QString&))
+{
+  m_progressCallback = callback;
+}
+
+void MyMoneyQifReader::signalProgress(int current, int total, const QString& msg)
+{
+  if(m_progressCallback != 0)
+    (*m_progressCallback)(current, total, msg);
+}
+
+void MyMoneyQifReader::processPriceEntry(void)
+{
+/*
+  !Type:Prices
+  "IBM",141 9/16,"10/23/98"
+  ^
+  !Type:Prices
+  "GMW",21.28," 3/17' 5"
+  ^
+  !Type:Prices
+  "GMW",71652181.001,"67/128/ 0"
+  ^
+
+  Note that Quicken will often put in a price with a bogus date and number.  We will ignore
+  prices with bogus dates.  Hopefully that will catch all of these.
+
+  Also note that prices can be in fractional units, e.g. 141 9/16.
+
+*/
+
+  QStringList::const_iterator it_line = m_qifEntry.begin();
+
+  // Make a price for each line
+  QRegExp priceExp("\"(.*)\",(.*),\"(.*)\"");
+  while ( it_line != m_qifEntry.end() )
+  {
+    if(priceExp.search(*it_line) != -1) {
+      MyMoneyStatement::Price price;
+      price.m_strSecurity = priceExp.cap(1);
+      QString pricestr = priceExp.cap(2);
+      QString datestr = priceExp.cap(3);
+      kdDebug(0) << "Price:" << price.m_strSecurity << " / " << pricestr << " / " << datestr << endl;
+
+      // Only add the price if the date is valid.  If invalid, fail silently.  See note above.
+      // Also require the price value to not have any slashes.  Old prices will be something like
+      // "25 9/16", which we do not support.  So we'll skip the price for now.
+      QDate date = m_qifProfile.date(datestr);
+      MyMoneyMoney rate(m_qifProfile.value('P', pricestr));
+      if(date.isValid() && !rate.isZero())
+      {
+        price.m_amount = rate;
+        price.m_date = date;
+        d->st.m_listPrices += price;
+      }
+    }
+    ++it_line;
+  }
+}
+
+void MyMoneyQifReader::processSecurityEntry(void)
+{
+  /*
+  !Type:Security
+  NVANGUARD 500 INDEX
+  SVFINX
+  TMutual Fund
+  ^
+  */
+
+  MyMoneyStatement::Security security;
+  security.m_strName = extractLine('N');
+  security.m_strSymbol = extractLine('S');
+
+  d->st.m_listSecurities += security;
+}
+
+#include "mymoneyqifreader.moc"